YES(O(1),O(n^4)) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , +(@x, @y) -> #add(@x, @y) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) } Weak Trs: { #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We add following dependency tuples: Strict DPs: { #abs^#(#0()) -> c_1() , #abs^#(#neg(@x)) -> c_2() , #abs^#(#pos(@x)) -> c_3() , #abs^#(#s(@x)) -> c_4() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , lineMult#1^#(nil(), @l) -> c_14() , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , makeBase#1^#(nil()) -> c_18() , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , mkBase#1^#(nil()) -> c_32() , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultList#1^#(nil(), @acc) -> c_28() , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#1^#(nil()) -> c_39() , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose#3^#(nil(), @l) -> c_49() , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } and mark the set of starting terms. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { #abs^#(#0()) -> c_1() , #abs^#(#neg(@x)) -> c_2() , #abs^#(#pos(@x)) -> c_3() , #abs^#(#s(@x)) -> c_4() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , lineMult#1^#(nil(), @l) -> c_14() , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , makeBase#1^#(nil()) -> c_18() , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , mkBase#1^#(nil()) -> c_32() , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultList#1^#(nil(), @acc) -> c_28() , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#1^#(nil()) -> c_39() , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose#3^#(nil(), @l) -> c_49() , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) Consider the dependency graph 1: #abs^#(#0()) -> c_1() 2: #abs^#(#neg(@x)) -> c_2() 3: #abs^#(#pos(@x)) -> c_3() 4: #abs^#(#s(@x)) -> c_4() 5: *^#(@x, @y) -> c_5(#mult^#(@x, @y)) -->_1 #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) :59 -->_1 #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) :58 -->_1 #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) :56 -->_1 #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) :55 -->_1 #mult^#(#pos(@x), #0()) -> c_57() :57 -->_1 #mult^#(#neg(@x), #0()) -> c_54() :54 -->_1 #mult^#(#0(), #pos(@y)) -> c_53() :53 -->_1 #mult^#(#0(), #neg(@y)) -> c_52() :52 -->_1 #mult^#(#0(), #0()) -> c_51() :51 6: +^#(@x, @y) -> c_6(#add^#(@x, @y)) -->_1 #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64 -->_1 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63 -->_1 #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :62 -->_1 #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) :61 -->_1 #add^#(#0(), @y) -> c_60() :60 7: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) -->_1 attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) :8 -->_1 attach#1^#(nil(), @m) -> c_9() :9 8: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) -->_1 attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) :10 -->_1 attach#2^#(nil(), @x, @xs) -> c_11() :11 9: attach#1^#(nil(), @m) -> c_9() 10: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) -->_1 attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) :7 11: attach#2^#(nil(), @x, @xs) -> c_11() 12: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) -->_1 lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) :13 -->_1 lineMult#1^#(nil(), @l) -> c_14() :14 13: lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) -->_1 mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) :15 -->_2 lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) :12 14: lineMult#1^#(nil(), @l) -> c_14() 15: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) -->_1 mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) :17 -->_1 mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) :16 16: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) -->_1 mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) :40 -->_1 mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) :39 17: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) -->_1 #abs^#(#0()) -> c_1() :1 18: makeBase^#(@m) -> c_16(makeBase#1^#(@m)) -->_1 makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) :19 -->_1 makeBase#1^#(nil()) -> c_18() :20 19: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) -->_1 mkBase^#(@m) -> c_19(mkBase#1^#(@m)) :21 20: makeBase#1^#(nil()) -> c_18() 21: mkBase^#(@m) -> c_19(mkBase#1^#(@m)) -->_1 mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) :22 -->_1 mkBase#1^#(nil()) -> c_32() :23 22: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) -->_1 mkBase^#(@m) -> c_19(mkBase#1^#(@m)) :21 23: mkBase#1^#(nil()) -> c_32() 24: matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) -->_2 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26 -->_1 matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) :25 -->_3 makeBase^#(@m) -> c_16(makeBase#1^#(@m)) :18 25: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) -->_1 matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :29 -->_1 matrixMult'#1^#(nil(), @m2) -> c_24() :30 26: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) -->_1 transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :27 -->_1 transAcc#1^#(nil(), @base) -> c_44() :28 27: transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) -->_2 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26 -->_1 attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) :7 28: transAcc#1^#(nil(), @base) -> c_44() 29: matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) -->_2 matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) :25 -->_1 lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) :12 30: matrixMult'#1^#(nil(), @m2) -> c_24() 31: matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) -->_2 matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :24 -->_1 matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :24 32: matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) -->_1 matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) :33 -->_1 matrixMultList#1^#(nil(), @acc) -> c_28() :34 33: matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) -->_1 matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) :32 -->_2 matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :24 34: matrixMultList#1^#(nil(), @acc) -> c_28() 35: matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) -->_2 transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) :36 -->_1 matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) :25 36: transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) -->_1 transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) :37 -->_1 transpose#1^#(nil(), @m) -> c_46() :38 37: transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) -->_1 transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) :47 -->_2 split^#(@m) -> c_37(split#1^#(@m)) :41 38: transpose#1^#(nil(), @m) -> c_46() 39: mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) -->_3 mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) :15 -->_1 +^#(@x, @y) -> c_6(#add^#(@x, @y)) :6 -->_2 *^#(@x, @y) -> c_5(#mult^#(@x, @y)) :5 40: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) -->_1 #abs^#(#0()) -> c_1() :1 41: split^#(@m) -> c_37(split#1^#(@m)) -->_1 split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) :42 -->_1 split#1^#(nil()) -> c_39() :43 42: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) -->_1 split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) :44 -->_1 split#2^#(nil(), @ls) -> c_41() :45 43: split#1^#(nil()) -> c_39() 44: split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) -->_1 split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() :46 -->_2 split^#(@m) -> c_37(split#1^#(@m)) :41 45: split#2^#(nil(), @ls) -> c_41() 46: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() 47: transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) -->_1 transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) :48 -->_1 transpose#3^#(nil(), @l) -> c_49() :49 48: transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) -->_1 transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) :36 49: transpose#3^#(nil(), @l) -> c_49() 50: transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) -->_1 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26 -->_2 makeBase^#(@m) -> c_16(makeBase#1^#(@m)) :18 51: #mult^#(#0(), #0()) -> c_51() 52: #mult^#(#0(), #neg(@y)) -> c_52() 53: #mult^#(#0(), #pos(@y)) -> c_53() 54: #mult^#(#neg(@x), #0()) -> c_54() 55: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_1 #natmult^#(#0(), @y) -> c_73() :65 56: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_1 #natmult^#(#0(), @y) -> c_73() :65 57: #mult^#(#pos(@x), #0()) -> c_57() 58: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_1 #natmult^#(#0(), @y) -> c_73() :65 59: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) -->_1 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_1 #natmult^#(#0(), @y) -> c_73() :65 60: #add^#(#0(), @y) -> c_60() 61: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) -->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70 -->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69 -->_1 #pred^#(#neg(#s(@x))) -> c_66() :68 -->_1 #pred^#(#0()) -> c_65() :67 62: #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) -->_2 #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64 -->_2 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63 -->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70 -->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69 -->_1 #pred^#(#neg(#s(@x))) -> c_66() :68 -->_1 #pred^#(#0()) -> c_65() :67 63: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) -->_1 #succ^#(#pos(#s(@x))) -> c_72() :74 -->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73 -->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72 -->_1 #succ^#(#0()) -> c_69() :71 64: #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) -->_1 #succ^#(#pos(#s(@x))) -> c_72() :74 -->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73 -->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72 -->_1 #succ^#(#0()) -> c_69() :71 -->_2 #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64 -->_2 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63 65: #natmult^#(#0(), @y) -> c_73() 66: #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) -->_1 #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) :76 -->_1 #natadd^#(#0(), @y) -> c_75() :75 -->_2 #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66 -->_2 #natmult^#(#0(), @y) -> c_73() :65 67: #pred^#(#0()) -> c_65() 68: #pred^#(#neg(#s(@x))) -> c_66() 69: #pred^#(#pos(#s(#0()))) -> c_67() 70: #pred^#(#pos(#s(#s(@x)))) -> c_68() 71: #succ^#(#0()) -> c_69() 72: #succ^#(#neg(#s(#0()))) -> c_70() 73: #succ^#(#neg(#s(#s(@x)))) -> c_71() 74: #succ^#(#pos(#s(@x))) -> c_72() 75: #natadd^#(#0(), @y) -> c_75() 76: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) -->_1 #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) :76 -->_1 #natadd^#(#0(), @y) -> c_75() :75 Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { #abs^#(#neg(@x)) -> c_2() , #abs^#(#pos(@x)) -> c_3() , #abs^#(#s(@x)) -> c_4() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { #abs^#(#0()) -> c_1() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , lineMult#1^#(nil(), @l) -> c_14() , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , makeBase#1^#(nil()) -> c_18() , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , mkBase#1^#(nil()) -> c_32() , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultList#1^#(nil(), @acc) -> c_28() , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#1^#(nil()) -> c_39() , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose#3^#(nil(), @l) -> c_49() , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We estimate the number of application of {1,2,3,6,8,11,17,20,25,27,31,35,40,42,43,46} by applications of Pre({1,2,3,6,8,11,17,20,25,27,31,35,40,42,43,46}) = {4,5,9,14,15,18,22,23,29,33,36,37,38,39,41,44}. Here rules are labeled as follows: DPs: { 1: #abs^#(#0()) -> c_1() , 2: *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , 3: +^#(@x, @y) -> c_6(#add^#(@x, @y)) , 4: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , 5: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , 6: attach#1^#(nil(), @m) -> c_9() , 7: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , 8: attach#2^#(nil(), @x, @xs) -> c_11() , 9: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , 10: lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , 11: lineMult#1^#(nil(), @l) -> c_14() , 12: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , 13: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , 14: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , 15: makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , 16: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , 17: makeBase#1^#(nil()) -> c_18() , 18: mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , 19: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , 20: mkBase#1^#(nil()) -> c_32() , 21: matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 22: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , 23: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , 24: transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , 25: transAcc#1^#(nil(), @base) -> c_44() , 26: matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 27: matrixMult'#1^#(nil(), @m2) -> c_24() , 28: matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 29: matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , 30: matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 31: matrixMultList#1^#(nil(), @acc) -> c_28() , 32: matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 33: transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , 34: transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , 35: transpose#1^#(nil(), @m) -> c_46() , 36: mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , 37: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , 38: split^#(@m) -> c_37(split#1^#(@m)) , 39: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , 40: split#1^#(nil()) -> c_39() , 41: split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , 42: split#2^#(nil(), @ls) -> c_41() , 43: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , 44: transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , 45: transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , 46: transpose#3^#(nil(), @l) -> c_49() , 47: transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) , 48: #mult^#(#0(), #0()) -> c_51() , 49: #mult^#(#0(), #neg(@y)) -> c_52() , 50: #mult^#(#0(), #pos(@y)) -> c_53() , 51: #mult^#(#neg(@x), #0()) -> c_54() , 52: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , 53: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , 54: #mult^#(#pos(@x), #0()) -> c_57() , 55: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , 56: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , 57: #add^#(#0(), @y) -> c_60() , 58: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , 59: #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 60: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , 61: #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 62: #natmult^#(#0(), @y) -> c_73() , 63: #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , 64: #pred^#(#0()) -> c_65() , 65: #pred^#(#neg(#s(@x))) -> c_66() , 66: #pred^#(#pos(#s(#0()))) -> c_67() , 67: #pred^#(#pos(#s(#s(@x)))) -> c_68() , 68: #succ^#(#0()) -> c_69() , 69: #succ^#(#neg(#s(#0()))) -> c_70() , 70: #succ^#(#neg(#s(#s(@x)))) -> c_71() , 71: #succ^#(#pos(#s(@x))) -> c_72() , 72: #natadd^#(#0(), @y) -> c_75() , 73: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #abs^#(#0()) -> c_1() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult#1^#(nil(), @l) -> c_14() , makeBase#1^#(nil()) -> c_18() , mkBase#1^#(nil()) -> c_32() , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMultList#1^#(nil(), @acc) -> c_28() , transpose#1^#(nil(), @m) -> c_46() , split#1^#(nil()) -> c_39() , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#3^#(nil(), @l) -> c_49() , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We estimate the number of application of {8,25} by applications of Pre({8,25}) = {6,7}. Here rules are labeled as follows: DPs: { 1: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , 2: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , 3: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , 4: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , 5: lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , 6: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , 7: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , 8: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , 9: makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , 10: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , 11: mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , 12: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , 13: matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 14: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , 15: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , 16: transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , 17: matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , 18: matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , 19: matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , 20: matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , 21: matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , 22: transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , 23: transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , 24: mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , 25: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , 26: split^#(@m) -> c_37(split#1^#(@m)) , 27: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , 28: split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , 29: transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , 30: transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , 31: transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) , 32: #abs^#(#0()) -> c_1() , 33: *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , 34: #mult^#(#0(), #0()) -> c_51() , 35: #mult^#(#0(), #neg(@y)) -> c_52() , 36: #mult^#(#0(), #pos(@y)) -> c_53() , 37: #mult^#(#neg(@x), #0()) -> c_54() , 38: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , 39: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , 40: #mult^#(#pos(@x), #0()) -> c_57() , 41: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , 42: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , 43: +^#(@x, @y) -> c_6(#add^#(@x, @y)) , 44: #add^#(#0(), @y) -> c_60() , 45: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , 46: #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 47: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , 48: #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 49: attach#1^#(nil(), @m) -> c_9() , 50: attach#2^#(nil(), @x, @xs) -> c_11() , 51: lineMult#1^#(nil(), @l) -> c_14() , 52: makeBase#1^#(nil()) -> c_18() , 53: mkBase#1^#(nil()) -> c_32() , 54: transAcc#1^#(nil(), @base) -> c_44() , 55: matrixMult'#1^#(nil(), @m2) -> c_24() , 56: matrixMultList#1^#(nil(), @acc) -> c_28() , 57: transpose#1^#(nil(), @m) -> c_46() , 58: split#1^#(nil()) -> c_39() , 59: split#2^#(nil(), @ls) -> c_41() , 60: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , 61: transpose#3^#(nil(), @l) -> c_49() , 62: #natmult^#(#0(), @y) -> c_73() , 63: #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , 64: #pred^#(#0()) -> c_65() , 65: #pred^#(#neg(#s(@x))) -> c_66() , 66: #pred^#(#pos(#s(#0()))) -> c_67() , 67: #pred^#(#pos(#s(#s(@x)))) -> c_68() , 68: #succ^#(#0()) -> c_69() , 69: #succ^#(#neg(#s(#0()))) -> c_70() , 70: #succ^#(#neg(#s(#s(@x)))) -> c_71() , 71: #succ^#(#pos(#s(@x))) -> c_72() , 72: #natadd^#(#0(), @y) -> c_75() , 73: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak DPs: { #abs^#(#0()) -> c_1() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult#1^#(nil(), @l) -> c_14() , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase#1^#(nil()) -> c_18() , mkBase#1^#(nil()) -> c_32() , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMultList#1^#(nil(), @acc) -> c_28() , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split#1^#(nil()) -> c_39() , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#3^#(nil(), @l) -> c_49() , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { #abs^#(#0()) -> c_1() , *^#(@x, @y) -> c_5(#mult^#(@x, @y)) , #mult^#(#0(), #0()) -> c_51() , #mult^#(#0(), #neg(@y)) -> c_52() , #mult^#(#0(), #pos(@y)) -> c_53() , #mult^#(#neg(@x), #0()) -> c_54() , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #0()) -> c_57() , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) , +^#(@x, @y) -> c_6(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_60() , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , attach#1^#(nil(), @m) -> c_9() , attach#2^#(nil(), @x, @xs) -> c_11() , lineMult#1^#(nil(), @l) -> c_14() , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) , makeBase#1^#(nil()) -> c_18() , mkBase#1^#(nil()) -> c_32() , transAcc#1^#(nil(), @base) -> c_44() , matrixMult'#1^#(nil(), @m2) -> c_24() , matrixMultList#1^#(nil(), @acc) -> c_28() , transpose#1^#(nil(), @m) -> c_46() , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) , split#1^#(nil()) -> c_39() , split#2^#(nil(), @ls) -> c_41() , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() , transpose#3^#(nil(), @l) -> c_49() , #natmult^#(#0(), @y) -> c_73() , #natmult^#(#s(@x), @y) -> c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) , #pred^#(#0()) -> c_65() , #pred^#(#neg(#s(@x))) -> c_66() , #pred^#(#pos(#s(#0()))) -> c_67() , #pred^#(#pos(#s(#s(@x)))) -> c_68() , #succ^#(#0()) -> c_69() , #succ^#(#neg(#s(#0()))) -> c_70() , #succ^#(#neg(#s(#s(@x)))) -> c_71() , #succ^#(#pos(#s(@x))) -> c_72() , #natadd^#(#0(), @y) -> c_75() , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_16(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) , mkBase^#(@m) -> c_19(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_25(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_26(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_27(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_45(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , split^#(@m) -> c_37(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { mult#2^#(::(@y, @ys), @x, @xs) -> c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys)) , split#2^#(::(@x, @xs), @ls) -> c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , matrixMult3(@m1, @m2, @m3) -> matrixMult(matrixMult(@m1, @m2), @m3) , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc) , matrixMultList#1(::(@m, @ms), @acc) -> matrixMultList(matrixMult(@acc, @m), @ms) , matrixMultList#1(nil(), @acc) -> @acc , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2)) , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , transpose'(@m) -> transAcc(@m, makeBase(@m)) , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We replace rewrite rules by usable rules: Weak Usable Rules: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We decompose the input problem according to the dependency graph into the upper component { matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } and lower component { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) } Further, following extension rules are added to the lower component. { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList^#(@acc, @mm) -> c_18(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose^#(@m) -> c_21(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMult3^#(@m1, @m2, @m3) -> c_17(matrixMult^#(matrixMult(@m1, @m2), @m3), matrixMult^#(@m1, @m2)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_19(matrixMultList^#(matrixMult(@acc, @m), @ms), matrixMult^#(@acc, @m)) , matrixMultOld^#(@m1, @m2) -> c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) , transpose#1^#(::(@xs, @xss), @m) -> c_22(transpose#2^#(split(@m)), split^#(@m)) , transpose'^#(@m) -> c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMult3^#(@m1, @m2, @m3) -> c_1() , matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_4(transpose^#(@m2)) , transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) , transpose'^#(@m) -> c_9() } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Consider the dependency graph 1: matrixMult3^#(@m1, @m2, @m3) -> c_1() 2: matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) -->_1 matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) :3 3: matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) -->_1 matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) :2 4: matrixMultOld^#(@m1, @m2) -> c_4(transpose^#(@m2)) -->_1 transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) :5 5: transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) -->_1 transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) :6 6: transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) -->_1 transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) :7 7: transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) -->_1 transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) :8 8: transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) -->_1 transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) :5 9: transpose'^#(@m) -> c_9() Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { matrixMult3^#(@m1, @m2, @m3) -> c_1() , matrixMultOld^#(@m1, @m2) -> c_4(transpose^#(@m2)) , transpose'^#(@m) -> c_9() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) , transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component: Problem (R): ------------ Strict DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Problem (S): ------------ Strict DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Overall, the transformation results in the following sub-problem(s): Generated new problems: ----------------------- R) Strict DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost This problem was proven YES(O(1),O(n^1)). S) Strict DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost This problem was proven YES(O(1),O(n^1)). Proofs for generated problems: ------------------------------ R) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We replace rewrite rules by usable rules: Weak Usable Rules: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 2: matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Trs: { #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach#1(nil(), @m) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base } Sub-proof: ---------- The following argument positions are usable: Uargs(c_2) = {1}, Uargs(c_3) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [0] [#pos](x1) = [1] x1 + [1] [#s](x1) = [0] [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x1 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [1] x1 + [1] [::](x1, x2) = [1] x1 + [1] x2 + [1] [attach#2](x1, x2, x3) = [1] x1 + [0] [nil] = [0] [lineMult](x1, x2) = [1] x2 + [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [0] [makeBase#1](x1) = [1] [mkBase](x1) = [0] [matrixMult](x1, x2) = [1] x1 + [1] [transAcc](x1, x2) = [0] [matrixMult'](x1, x2) = [1] x2 + [0] [matrixMult'#1](x1, x2) = [1] x1 + [1] [transpose](x1) = [0] [mkBase#1](x1) = [1] [mult#1](x1, x2) = [1] x1 + [1] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [0] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x2 + [1] [transpose#1](x1, x2) = [0] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [0] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [0] [transAcc#1^#](x1, x2) = [0] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [0] [matrixMultList^#](x1, x2) = [1] x2 + [0] [matrixMultList#1^#](x1, x2) = [1] x1 + [0] [matrixMultOld^#](x1, x2) = [0] [transpose^#](x1) = [0] [transpose#1^#](x1, x2) = [0] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [0] [transpose#3^#](x1, x2) = [0] [transpose'^#](x1) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_5](x1) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1) = [0] This order satisfies following ordering constraints [matrixMultList^#(@acc, @mm)] = [1] @mm + [0] >= [1] @mm + [0] = [c_2(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] > [1] @ms + [0] = [c_3(matrixMultList^#(matrixMult(@acc, @m), @ms))] Consider the set of all dependency pairs DPs: { 1: matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , 2: matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2}. These cover all (indirect) predecessors of dependency pairs {1,2}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded S) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak DPs: { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { matrixMultList^#(@acc, @mm) -> c_2(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_3(matrixMultList^#(matrixMult(@acc, @m), @ms)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We replace rewrite rules by usable rules: Weak Usable Rules: { split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak Trs: { split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 3: transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0] [0] [#neg](x1) = [0 0] x1 + [0] [1 1] [0] [#pos](x1) = [0] [0] [#s](x1) = [0] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [0] [0] [#add](x1, x2) = [0] [0] [attach](x1, x2) = [0] [0] [attach#1](x1, x2) = [0] [0] [::](x1, x2) = [0 0] x1 + [0 0] x2 + [1] [1 1] [1 1] [0] [attach#2](x1, x2, x3) = [0] [0] [nil] = [0] [1] [lineMult](x1, x2) = [0] [0] [lineMult#1](x1, x2) = [0] [0] [mult](x1, x2) = [0] [0] [makeBase](x1) = [0] [0] [makeBase#1](x1) = [0] [0] [mkBase](x1) = [0] [0] [matrixMult](x1, x2) = [0] [0] [transAcc](x1, x2) = [0] [0] [matrixMult'](x1, x2) = [0] [0] [matrixMult'#1](x1, x2) = [0] [0] [transpose](x1) = [0] [0] [mkBase#1](x1) = [0] [0] [mult#1](x1, x2) = [0] [0] [mult#2](x1, x2, x3) = [0] [0] [split](x1) = [0 0] x1 + [0] [0 1] [1] [split#1](x1) = [0 0] x1 + [0] [0 1] [1] [split#2](x1, x2) = [0 0] x1 + [0 0] x2 + [0] [1 1] [0 1] [1] [tuple#2](x1, x2) = [0 0] x2 + [0] [1 1] [1] [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x3 + [0] [0 1] [1 1] [1] [transAcc#1](x1, x2) = [0] [0] [transpose#1](x1, x2) = [0] [0] [transpose#2](x1) = [0] [0] [transpose#3](x1, x2) = [0] [0] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [0] [0] [#natadd](x1, x2) = [0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [0] [0] [lineMult#1^#](x1, x2) = [0] [0] [mult^#](x1, x2) = [0] [0] [mult#1^#](x1, x2) = [0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [0] [0] [matrixMult'^#](x1, x2) = [0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [0] [0] [matrixMult3^#](x1, x2, x3) = [0] [0] [matrixMultList^#](x1, x2) = [0] [0] [matrixMultList#1^#](x1, x2) = [0] [0] [matrixMultOld^#](x1, x2) = [0] [0] [transpose^#](x1) = [1 1] x1 + [0] [0 1] [0] [transpose#1^#](x1, x2) = [1 0] x1 + [0 1] x2 + [0] [0 0] [0 0] [0] [mult#2^#](x1, x2, x3) = [0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0 1] x1 + [0] [1 0] [0] [transpose#3^#](x1, x2) = [1 1] x1 + [0] [0 0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1) = [1 1] x1 + [0] [0 0] [0] [c_7](x1) = [1 1] x1 + [0] [0 0] [0] [c_8](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [split(@m)] = [0 0] @m + [0] [0 1] [1] >= [0 0] @m + [0] [0 1] [1] = [split#1(@m)] [split#1(::(@l, @ls))] = [0 0] @l + [0 0] @ls + [0] [1 1] [1 1] [1] >= [0 0] @l + [0 0] @ls + [0] [1 1] [0 1] [1] = [split#2(@l, @ls)] [split#1(nil())] = [0] [2] >= [0] [2] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [0 0] @ls + [0 0] @x + [0 0] @xs + [0] [0 1] [1 1] [1 1] [2] >= [0 0] @ls + [0 0] @xs + [0] [0 1] [1 1] [2] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [0 0] @ls + [0] [0 1] [2] >= [0] [2] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [0 0] @m' + [0 0] @xs + [0] [1 1] [1 1] [2] >= [0 0] @m' + [0 0] @xs + [0] [1 1] [1 1] [2] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transpose^#(@m)] = [1 1] @m + [0] [0 1] [0] >= [1 1] @m + [0] [0 0] [0] = [c_5(transpose#1^#(@m, @m))] [transpose#1^#(::(@xs, @xss), @m)] = [0 1] @m + [1] [0 0] [0] >= [0 1] @m + [1] [0 0] [0] = [c_6(transpose#2^#(split(@m)))] [transpose#2^#(tuple#2(@l, @m'))] = [1 1] @m' + [1] [0 0] [0] > [1 1] @m' + [0] [0 0] [0] = [c_7(transpose#3^#(@m', @l))] [transpose#3^#(::(@y, @ys), @l)] = [1 1] @y + [1 1] @ys + [1] [0 0] [0 0] [0] >= [1 1] @y + [1 1] @ys + [1] [0 0] [0 0] [0] = [c_8(transpose^#(::(@y, @ys)))] Consider the set of all dependency pairs DPs: { 1: transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , 2: transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , 3: transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , 4: transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {3}. These cover all (indirect) predecessors of dependency pairs {1,2,3,4}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } Weak Trs: { split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { transpose^#(@m) -> c_5(transpose#1^#(@m, @m)) , transpose#1^#(::(@xs, @xss), @m) -> c_6(transpose#2^#(split(@m))) , transpose#2^#(tuple#2(@l, @m')) -> c_7(transpose#3^#(@m', @l)) , transpose#3^#(::(@y, @ys), @l) -> c_8(transpose^#(::(@y, @ys))) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) } Weak DPs: { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component: Problem (R): ------------ Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Problem (S): ------------ Strict DPs: { split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) } Weak DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Overall, the transformation results in the following sub-problem(s): Generated new problems: ----------------------- R) Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost This problem was proven YES(O(1),O(n^3)). S) Strict DPs: { split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) } Weak DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost This problem was proven YES(O(1),O(n^1)). Proofs for generated problems: ------------------------------ R) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) Consider the dependency graph 1: attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) -->_1 attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) :2 2: attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) -->_1 attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) :3 3: attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) -->_1 attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) :1 4: lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) -->_1 lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) :5 5: lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) -->_1 mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) :6 -->_2 lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) :4 6: mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) -->_1 mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) :7 7: mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) -->_1 mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) :17 8: makeBase^#(@m) -> c_8(makeBase#1^#(@m)) -->_1 makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) :9 9: makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) -->_1 mkBase^#(@m) -> c_10(mkBase#1^#(@m)) :10 10: mkBase^#(@m) -> c_10(mkBase#1^#(@m)) -->_1 mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) :11 11: mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) -->_1 mkBase^#(@m) -> c_10(mkBase#1^#(@m)) :10 12: matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) -->_2 transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) :14 -->_1 matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) :13 -->_3 makeBase^#(@m) -> c_8(makeBase#1^#(@m)) :8 13: matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) -->_1 matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :16 14: transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) -->_1 transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) :15 15: transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) -->_2 transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) :14 -->_1 attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) :1 16: matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) -->_2 matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) :13 -->_1 lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) :4 17: mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) -->_1 mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) :6 18: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) -->_1 matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :12 19: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) -->_1 matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :12 20: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) -->_1 matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) :22 -->_1 matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) :21 21: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) -->_1 matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) :12 22: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) -->_1 matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) :20 23: matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) -->_1 matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) :13 24: transpose'^#(@m) -> makeBase^#(@m) -->_1 makeBase^#(@m) -> c_8(makeBase#1^#(@m)) :8 25: transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) -->_1 transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) :14 Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , transpose'^#(@m) -> makeBase^#(@m) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^3)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^3)) We decompose the input problem according to the dependency graph into the upper component { makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } and lower component { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Further, following extension rules are added to the lower component. { makeBase^#(@m) -> makeBase#1^#(@m) , makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) , mkBase^#(@m) -> mkBase#1^#(@m) , mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') , matrixMult^#(@m1, @m2) -> makeBase^#(@m2) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2)) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) , transAcc#1^#(::(@l, @m'), @base) -> attach^#(@l, transAcc(@m', @base)) , transAcc#1^#(::(@l, @m'), @base) -> transAcc^#(@m', @base) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) } Weak DPs: { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { makeBase^#(@m) -> c_1(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@l)) , mkBase^#(@m) -> c_3(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_5(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_6(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_7(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_8(transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_9(matrixMult'^#(@ls, @m2)) } Weak DPs: { matrixMult3^#(@m1, @m2, @m3) -> c_10(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_11(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_12(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_13(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_14(matrixMult'^#(@m1, transpose(@m2))) , transpose'^#(@m) -> c_15(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 9: matrixMult'#1^#(::(@l, @ls), @m2) -> c_9(matrixMult'^#(@ls, @m2)) , 10: matrixMult3^#(@m1, @m2, @m3) -> c_10(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 11: matrixMultList^#(@acc, @mm) -> c_11(matrixMultList#1^#(@mm, @acc)) , 12: matrixMultList#1^#(::(@m, @ms), @acc) -> c_12(matrixMult^#(@acc, @m)) , 14: matrixMultOld^#(@m1, @m2) -> c_14(matrixMult'^#(@m1, transpose(@m2))) } Trs: { #abs(#neg(@x)) -> #pos(@x) , attach#1(nil(), @m) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , transAcc(@m, @base) -> transAcc#1(@m, @base) , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [1] [#abs](x1) = [1] x1 + [0] [#neg](x1) = [1] [#pos](x1) = [0] [#s](x1) = [0] [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x1 + [0] [#add](x1, x2) = [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [1] x1 + [1] [::](x1, x2) = [1] x2 + [1] [attach#2](x1, x2, x3) = [1] x1 + [0] [nil] = [1] [lineMult](x1, x2) = [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [1] x1 + [1] [makeBase#1](x1) = [1] x1 + [1] [mkBase](x1) = [0] [matrixMult](x1, x2) = [1] x1 + [0] [transAcc](x1, x2) = [1] x1 + [1] x2 + [1] [matrixMult'](x1, x2) = [1] x1 + [0] [matrixMult'#1](x1, x2) = [1] x1 + [0] [transpose](x1) = [0] [mkBase#1](x1) = [0] [mult#1](x1, x2) = [1] [mult#2](x1, x2, x3) = [0] [split](x1) = [1] x1 + [0] [split#1](x1) = [1] x1 + [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [0] [split#3](x1, x2, x3) = [1] x1 + [0] [transAcc#1](x1, x2) = [1] x1 + [1] x2 + [0] [transpose#1](x1, x2) = [0] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [1] [#natadd](x1, x2) = [1] x2 + [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [1] x1 + [0] [matrixMult'^#](x1, x2) = [1] x1 + [0] [transAcc^#](x1, x2) = [0] [transAcc#1^#](x1, x2) = [0] [matrixMult'#1^#](x1, x2) = [1] x1 + [0] [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMultList^#](x1, x2) = [1] x1 + [1] x2 + [1] [matrixMultList#1^#](x1, x2) = [1] x1 + [1] x2 + [0] [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1] [transpose^#](x1) = [0] [transpose#1^#](x1, x2) = [0] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [0] [transpose#3^#](x1, x2) = [0] [transpose'^#](x1) = [1] x1 + [1] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1, x2, x3) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1, x2) = [0] [c_16](x1, x2) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1) = [1] x1 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [1] This order satisfies following ordering constraints [matrixMult(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))] [matrixMult'(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [matrixMult'#1(@m1, @m2)] [matrixMult'#1(::(@l, @ls), @m2)] = [1] @ls + [1] >= [1] @ls + [1] = [::(lineMult(@l, @m2), matrixMult'(@ls, @m2))] [matrixMult'#1(nil(), @m2)] = [1] >= [1] = [nil()] [#natmult(#0(), @y)] = [1] >= [1] = [#0()] [#natmult(#s(@x), @y)] = [1] >= [1] = [#natadd(@y, #natmult(@x, @y))] [#natadd(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#natadd(#s(@x), @y)] = [1] @y + [0] >= [0] = [#s(#natadd(@x, @y))] [makeBase^#(@m)] = [0] >= [0] = [c_1(makeBase#1^#(@m))] [makeBase#1^#(::(@l, @m'))] = [0] >= [0] = [c_2(mkBase^#(@l))] [mkBase^#(@m)] = [0] >= [0] = [c_3(mkBase#1^#(@m))] [mkBase#1^#(::(@l, @m'))] = [0] >= [0] = [c_4(mkBase^#(@m'))] [matrixMult^#(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [c_5(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2))] [matrixMult'^#(@m1, @m2)] = [1] @m1 + [0] >= [1] @m1 + [0] = [c_6(matrixMult'#1^#(@m1, @m2))] [transAcc^#(@m, @base)] = [0] >= [0] = [c_7(transAcc#1^#(@m, @base))] [transAcc#1^#(::(@l, @m'), @base)] = [0] >= [0] = [c_8(transAcc^#(@m', @base))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [1] @ls + [1] > [1] @ls + [0] = [c_9(matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1] @m1 + [1] @m2 + [1] @m3 + [1] > [1] @m1 + [0] = [c_10(matrixMult^#(matrixMult(@m1, @m2), @m3))] [matrixMultList^#(@acc, @mm)] = [1] @acc + [1] @mm + [1] > [1] @acc + [1] @mm + [0] = [c_11(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @acc + [1] @ms + [1] > [1] @acc + [0] = [c_12(matrixMult^#(@acc, @m))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @acc + [1] @ms + [1] >= [1] @acc + [1] @ms + [1] = [c_13(matrixMultList^#(matrixMult(@acc, @m), @ms))] [matrixMultOld^#(@m1, @m2)] = [1] @m1 + [1] @m2 + [1] > [1] @m1 + [0] = [c_14(matrixMult'^#(@m1, transpose(@m2)))] [transpose'^#(@m)] = [1] @m + [1] >= [1] = [c_15(transAcc^#(@m, makeBase(@m)))] Consider the set of all dependency pairs DPs: { 1: makeBase^#(@m) -> c_1(makeBase#1^#(@m)) , 2: makeBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@l)) , 3: mkBase^#(@m) -> c_3(mkBase#1^#(@m)) , 4: mkBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@m')) , 5: matrixMult^#(@m1, @m2) -> c_5(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 6: matrixMult'^#(@m1, @m2) -> c_6(matrixMult'#1^#(@m1, @m2)) , 7: transAcc^#(@m, @base) -> c_7(transAcc#1^#(@m, @base)) , 8: transAcc#1^#(::(@l, @m'), @base) -> c_8(transAcc^#(@m', @base)) , 9: matrixMult'#1^#(::(@l, @ls), @m2) -> c_9(matrixMult'^#(@ls, @m2)) , 10: matrixMult3^#(@m1, @m2, @m3) -> c_10(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 11: matrixMultList^#(@acc, @mm) -> c_11(matrixMultList#1^#(@mm, @acc)) , 12: matrixMultList#1^#(::(@m, @ms), @acc) -> c_12(matrixMult^#(@acc, @m)) , 13: matrixMultList#1^#(::(@m, @ms), @acc) -> c_13(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 14: matrixMultOld^#(@m1, @m2) -> c_14(matrixMult'^#(@m1, transpose(@m2))) , 15: transpose'^#(@m) -> c_15(transAcc^#(@m, makeBase(@m))) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {9,10,11,12,14}. These cover all (indirect) predecessors of dependency pairs {1,2,5,6,9,10,11,12,13,14,15}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { mkBase^#(@m) -> c_3(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@m')) , transAcc^#(@m, @base) -> c_7(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_8(transAcc^#(@m', @base)) } Weak DPs: { makeBase^#(@m) -> c_1(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_5(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_6(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_9(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_10(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_11(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_12(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_13(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_14(matrixMult'^#(@m1, transpose(@m2))) , transpose'^#(@m) -> c_15(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { matrixMult'^#(@m1, @m2) -> c_6(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_9(matrixMult'^#(@ls, @m2)) , matrixMultOld^#(@m1, @m2) -> c_14(matrixMult'^#(@m1, transpose(@m2))) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { mkBase^#(@m) -> c_3(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@m')) , transAcc^#(@m, @base) -> c_7(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_8(transAcc^#(@m', @base)) } Weak DPs: { makeBase^#(@m) -> c_1(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_5(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_10(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_11(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_12(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_13(matrixMultList^#(matrixMult(@acc, @m), @ms)) , transpose'^#(@m) -> c_15(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMult^#(@m1, @m2) -> c_5(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) } We apply the transformation 'usablerules' on the sub-problem: Strict DPs: { mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) , transAcc^#(@m, @base) -> c_3(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_4(transAcc^#(@m', @base)) } Weak DPs: { makeBase^#(@m) -> c_5(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_8(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_9(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms)) , transpose'^#(@m) -> c_12(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost We replace rewrite rules by usable rules: Weak Usable Rules: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) , transAcc^#(@m, @base) -> c_3(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_4(transAcc^#(@m', @base)) } Weak DPs: { makeBase^#(@m) -> c_5(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_8(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_9(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms)) , transpose'^#(@m) -> c_12(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 4: transAcc#1^#(::(@l, @m'), @base) -> c_4(transAcc^#(@m', @base)) , 7: matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 11: matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 12: transpose'^#(@m) -> c_12(transAcc^#(@m, makeBase(@m))) } Trs: { *(@x, @y) -> #mult(@x, @y) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach#1(nil(), @m) -> nil() , attach#2(nil(), @x, @xs) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1, 2}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [1] x1 + [0] [#pos](x1) = [1] [#s](x1) = [0] [*](x1, x2) = [1] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [1] x1 + [1] [::](x1, x2) = [1] x1 + [1] x2 + [1] [attach#2](x1, x2, x3) = [1] x1 + [1] [nil] = [0] [lineMult](x1, x2) = [1] x2 + [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [1] x1 + [1] [makeBase#1](x1) = [1] x1 + [1] [mkBase](x1) = [0] [matrixMult](x1, x2) = [0] [transAcc](x1, x2) = [1] x1 + [0] [matrixMult'](x1, x2) = [0] [matrixMult'#1](x1, x2) = [1] x1 + [0] [transpose](x1) = [0] [mkBase#1](x1) = [0] [mult#1](x1, x2) = [1] x1 + [0] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [0] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x1 + [1] x2 + [0] [transpose#1](x1, x2) = [0] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [1] x2 + [1] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [1] x1 + [0] [transAcc#1^#](x1, x2) = [1] x1 + [0] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMultList^#](x1, x2) = [1] x2 + [0] [matrixMultList#1^#](x1, x2) = [1] x1 + [0] [matrixMultOld^#](x1, x2) = [0] [transpose^#](x1) = [0] [transpose#1^#](x1, x2) = [0] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [0] [transpose#3^#](x1, x2) = [0] [transpose'^#](x1) = [1] x1 + [1] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1, x2, x3) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1, x2) = [0] [c_16](x1, x2) = [0] [c] = [0] [c_1](x1) = [0] [c_2](x1) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1, x2, x3) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1, x2) = [1] x1 + [1] x2 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1) = [1] x1 + [0] [c_12](x1) = [1] x1 + [0] This order satisfies following ordering constraints [makeBase^#(@m)] = [0] >= [0] = [c_5(makeBase#1^#(@m))] [makeBase#1^#(::(@l, @m'))] = [0] >= [0] = [c_6(mkBase^#(@l))] [mkBase^#(@m)] = [0] >= [0] = [c_1(mkBase#1^#(@m))] [mkBase#1^#(::(@l, @m'))] = [0] >= [0] = [c_2(mkBase^#(@m'))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [1] > [1] @m2 + [0] = [c_7(transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2))] [transAcc^#(@m, @base)] = [1] @m + [0] >= [1] @m + [0] = [c_3(transAcc#1^#(@m, @base))] [transAcc#1^#(::(@l, @m'), @base)] = [1] @l + [1] @m' + [1] > [1] @m' + [0] = [c_4(transAcc^#(@m', @base))] [matrixMult3^#(@m1, @m2, @m3)] = [1] @m1 + [1] @m2 + [1] @m3 + [1] >= [1] @m3 + [1] = [c_8(matrixMult^#(matrixMult(@m1, @m2), @m3))] [matrixMultList^#(@acc, @mm)] = [1] @mm + [0] >= [1] @mm + [0] = [c_9(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] >= [1] @m + [1] = [c_10(matrixMult^#(@acc, @m))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] > [1] @ms + [0] = [c_11(matrixMultList^#(matrixMult(@acc, @m), @ms))] [transpose'^#(@m)] = [1] @m + [1] > [1] @m + [0] = [c_12(transAcc^#(@m, makeBase(@m)))] Consider the set of all dependency pairs DPs: { 1: mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , 2: mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) , 3: transAcc^#(@m, @base) -> c_3(transAcc#1^#(@m, @base)) , 4: transAcc#1^#(::(@l, @m'), @base) -> c_4(transAcc^#(@m', @base)) , 5: makeBase^#(@m) -> c_5(makeBase#1^#(@m)) , 6: makeBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@l)) , 7: matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , 8: matrixMult3^#(@m1, @m2, @m3) -> c_8(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 9: matrixMultList^#(@acc, @mm) -> c_9(matrixMultList#1^#(@mm, @acc)) , 10: matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMult^#(@acc, @m)) , 11: matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 12: transpose'^#(@m) -> c_12(transAcc^#(@m, makeBase(@m))) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {4,7,11,12}. These cover all (indirect) predecessors of dependency pairs {3,4,5,6,7,8,9,10,11,12}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) } Weak DPs: { makeBase^#(@m) -> c_5(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , transAcc^#(@m, @base) -> c_3(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_4(transAcc^#(@m', @base)) , matrixMult3^#(@m1, @m2, @m3) -> c_8(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_9(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms)) , transpose'^#(@m) -> c_12(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { transAcc^#(@m, @base) -> c_3(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_4(transAcc^#(@m', @base)) , transpose'^#(@m) -> c_12(transAcc^#(@m, makeBase(@m))) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) } Weak DPs: { makeBase^#(@m) -> c_5(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_8(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_9(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_10(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_11(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) } Weak DPs: { makeBase^#(@m) -> c_3(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@l)) , matrixMult^#(@m1, @m2) -> c_5(makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_6(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_7(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_8(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 2: mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) , 4: makeBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@l)) , 6: matrixMult3^#(@m1, @m2, @m3) -> c_6(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 7: matrixMultList^#(@acc, @mm) -> c_7(matrixMultList#1^#(@mm, @acc)) , 8: matrixMultList#1^#(::(@m, @ms), @acc) -> c_8(matrixMult^#(@acc, @m)) } Trs: { makeBase(@m) -> makeBase#1(@m) , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [0] [#pos](x1) = [1] x1 + [0] [#s](x1) = [1] x1 + [0] [*](x1, x2) = [1] [#mult](x1, x2) = [1] x2 + [0] [+](x1, x2) = [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [attach#2](x1, x2, x3) = [0] [nil] = [1] [lineMult](x1, x2) = [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [1] [makeBase](x1) = [1] [makeBase#1](x1) = [0] [mkBase](x1) = [0] [matrixMult](x1, x2) = [0] [transAcc](x1, x2) = [0] [matrixMult'](x1, x2) = [1] x2 + [0] [matrixMult'#1](x1, x2) = [0] [transpose](x1) = [0] [mkBase#1](x1) = [0] [mult#1](x1, x2) = [1] x1 + [0] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [0] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x2 + [0] [transpose#1](x1, x2) = [0] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [1] x1 + [0] [makeBase#1^#](x1) = [1] x1 + [0] [mkBase^#](x1) = [1] x1 + [0] [mkBase#1^#](x1) = [1] x1 + [0] [matrixMult^#](x1, x2) = [1] x2 + [0] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [0] [transAcc#1^#](x1, x2) = [0] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMultList^#](x1, x2) = [1] x2 + [1] [matrixMultList#1^#](x1, x2) = [1] x1 + [0] [matrixMultOld^#](x1, x2) = [0] [transpose^#](x1) = [0] [transpose#1^#](x1, x2) = [0] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [0] [transpose#3^#](x1, x2) = [0] [transpose'^#](x1) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1, x2, x3) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1, x2) = [0] [c_16](x1, x2) = [0] [c] = [0] [c_1](x1) = [0] [c_2](x1) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1, x2, x3) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1) = [0] [c] = [0] [c_1](x1) = [0] [c_2](x1) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1) = [0] [c_6](x1) = [0] [c_7](x1, x2) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] This order satisfies following ordering constraints [makeBase^#(@m)] = [1] @m + [0] >= [1] @m + [0] = [c_3(makeBase#1^#(@m))] [makeBase#1^#(::(@l, @m'))] = [1] @l + [1] @m' + [1] > [1] @l + [0] = [c_4(mkBase^#(@l))] [mkBase^#(@m)] = [1] @m + [0] >= [1] @m + [0] = [c_1(mkBase#1^#(@m))] [mkBase#1^#(::(@l, @m'))] = [1] @l + [1] @m' + [1] > [1] @m' + [0] = [c_2(mkBase^#(@m'))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [0] >= [1] @m2 + [0] = [c_5(makeBase^#(@m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1] @m1 + [1] @m2 + [1] @m3 + [1] > [1] @m3 + [0] = [c_6(matrixMult^#(matrixMult(@m1, @m2), @m3))] [matrixMultList^#(@acc, @mm)] = [1] @mm + [1] > [1] @mm + [0] = [c_7(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] > [1] @m + [0] = [c_8(matrixMult^#(@acc, @m))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] >= [1] @ms + [1] = [c_9(matrixMultList^#(matrixMult(@acc, @m), @ms))] Consider the set of all dependency pairs DPs: { 1: mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , 2: mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) , 3: makeBase^#(@m) -> c_3(makeBase#1^#(@m)) , 4: makeBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@l)) , 5: matrixMult^#(@m1, @m2) -> c_5(makeBase^#(@m2)) , 6: matrixMult3^#(@m1, @m2, @m3) -> c_6(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 7: matrixMultList^#(@acc, @mm) -> c_7(matrixMultList#1^#(@mm, @acc)) , 8: matrixMultList#1^#(::(@m, @ms), @acc) -> c_8(matrixMult^#(@acc, @m)) , 9: matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,4,6,7,8}. These cover all (indirect) predecessors of dependency pairs {1,2,3,4,5,6,7,8,9}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { makeBase^#(@m) -> c_3(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@l)) , mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_5(makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_6(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_7(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_8(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMultList^#(matrixMult(@acc, @m), @ms)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { makeBase^#(@m) -> c_3(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_4(mkBase^#(@l)) , mkBase^#(@m) -> c_1(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_2(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_5(makeBase^#(@m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_6(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_7(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_8(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_9(matrixMultList^#(matrixMult(@acc, @m), @ms)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { makeBase^#(@m) -> makeBase#1^#(@m) , makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) , mkBase^#(@m) -> mkBase#1^#(@m) , mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') , matrixMult^#(@m1, @m2) -> makeBase^#(@m2) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2)) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) , transAcc#1^#(::(@l, @m'), @base) -> attach^#(@l, transAcc(@m', @base)) , transAcc#1^#(::(@l, @m'), @base) -> transAcc^#(@m', @base) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { makeBase^#(@m) -> makeBase#1^#(@m) , makeBase#1^#(::(@l, @m')) -> mkBase^#(@l) , mkBase^#(@m) -> mkBase#1^#(@m) , mkBase#1^#(::(@l, @m')) -> mkBase^#(@m') , matrixMult^#(@m1, @m2) -> makeBase^#(@m2) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2)) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) , transAcc#1^#(::(@l, @m'), @base) -> attach^#(@l, transAcc(@m', @base)) , transAcc#1^#(::(@l, @m'), @base) -> transAcc^#(@m', @base) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We decompose the input problem according to the dependency graph into the upper component { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2)) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) , transAcc#1^#(::(@l, @m'), @base) -> attach^#(@l, transAcc(@m', @base)) , transAcc#1^#(::(@l, @m'), @base) -> transAcc^#(@m', @base) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } and lower component { mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Further, following extension rules are added to the lower component. { attach^#(@line, @m) -> attach#1^#(@line, @m) , attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) , attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) , lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) , lineMult#1^#(::(@x, @xs), @l) -> lineMult^#(@l, @xs) , lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2)) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) , transAcc#1^#(::(@l, @m'), @base) -> attach^#(@l, transAcc(@m', @base)) , transAcc#1^#(::(@l, @m'), @base) -> transAcc^#(@m', @base) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) } Weak DPs: { matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2)) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) , transAcc#1^#(::(@l, @m'), @base) -> attach^#(@l, transAcc(@m', @base)) , transAcc#1^#(::(@l, @m'), @base) -> transAcc^#(@m', @base) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(lineMult^#(@l, @xs)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> c_8(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_9(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_10(attach^#(@l, transAcc(@m', @base))) , transAcc#1^#(::(@l, @m'), @base) -> c_11(transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_12(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_13(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_14(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_15(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_16(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_17(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_18(matrixMult'^#(@m1, transpose(@m2))) , transpose'^#(@m) -> c_19(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 2: attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , 6: matrixMult^#(@m1, @m2) -> c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 10: transAcc#1^#(::(@l, @m'), @base) -> c_10(attach^#(@l, transAcc(@m', @base))) , 15: matrixMultList^#(@acc, @mm) -> c_15(matrixMultList#1^#(@mm, @acc)) , 18: matrixMultOld^#(@m1, @m2) -> c_18(matrixMult'^#(@m1, transpose(@m2))) } Trs: { attach#1(nil(), @m) -> nil() , attach#2(nil(), @x, @xs) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [1] [#abs](x1) = [0] [#neg](x1) = [1] x1 + [1] [#pos](x1) = [0] [#s](x1) = [1] [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [1] x1 + [0] [#add](x1, x2) = [1] x2 + [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [1] x1 + [1] [::](x1, x2) = [1] x1 + [1] x2 + [1] [attach#2](x1, x2, x3) = [1] x1 + [1] [nil] = [0] [lineMult](x1, x2) = [1] x2 + [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [0] [makeBase#1](x1) = [1] x1 + [1] [mkBase](x1) = [0] [matrixMult](x1, x2) = [0] [transAcc](x1, x2) = [0] [matrixMult'](x1, x2) = [0] [matrixMult'#1](x1, x2) = [1] x1 + [0] [transpose](x1) = [0] [mkBase#1](x1) = [0] [mult#1](x1, x2) = [1] [mult#2](x1, x2, x3) = [0] [split](x1) = [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [tuple#2](x1, x2) = [0] [split#3](x1, x2, x3) = [0] [transAcc#1](x1, x2) = [1] x2 + [1] [transpose#1](x1, x2) = [1] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [1] x1 + [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [1] x1 + [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [1] x1 + [0] [attach#1^#](x1, x2) = [1] x1 + [0] [attach#2^#](x1, x2, x3) = [1] x3 + [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [1] x2 + [1] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [1] x1 + [1] [transAcc#1^#](x1, x2) = [1] x1 + [1] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [matrixMultList^#](x1, x2) = [1] x2 + [1] [matrixMultList#1^#](x1, x2) = [1] x1 + [0] [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1] [transpose^#](x1) = [0] [transpose#1^#](x1, x2) = [0] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [0] [transpose#3^#](x1, x2) = [0] [transpose'^#](x1) = [1] x1 + [1] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_1](x1) = [0] [c_2](x1) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1, x2) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1) = [1] x1 + [1] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] This order satisfies following ordering constraints [attach^#(@line, @m)] = [1] @line + [0] >= [1] @line + [0] = [c_1(attach#1^#(@line, @m))] [attach#1^#(::(@x, @xs), @m)] = [1] @x + [1] @xs + [1] > [1] @xs + [0] = [c_2(attach#2^#(@m, @x, @xs))] [attach#2^#(::(@l, @ls), @x, @xs)] = [1] @xs + [0] >= [1] @xs + [0] = [c_3(attach^#(@xs, @ls))] [lineMult^#(@l, @m2)] = [0] >= [0] = [c_4(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0] >= [0] = [c_5(lineMult^#(@l, @xs))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [1] > [0] = [c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))] [matrixMult^#(@m1, @m2)] = [1] @m2 + [1] >= [1] @m2 + [1] = [c_7(transAcc^#(@m2, makeBase(@m2)))] [matrixMult'^#(@m1, @m2)] = [0] >= [0] = [c_8(matrixMult'#1^#(@m1, @m2))] [transAcc^#(@m, @base)] = [1] @m + [1] >= [1] @m + [1] = [c_9(transAcc#1^#(@m, @base))] [transAcc#1^#(::(@l, @m'), @base)] = [1] @l + [1] @m' + [2] > [1] @l + [0] = [c_10(attach^#(@l, transAcc(@m', @base)))] [transAcc#1^#(::(@l, @m'), @base)] = [1] @l + [1] @m' + [2] >= [1] @m' + [2] = [c_11(transAcc^#(@m', @base))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0] >= [0] = [c_12(lineMult^#(@l, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0] >= [0] = [c_13(matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1] @m1 + [1] @m2 + [1] @m3 + [1] >= [1] @m3 + [1] = [c_14(matrixMult^#(matrixMult(@m1, @m2), @m3))] [matrixMultList^#(@acc, @mm)] = [1] @mm + [1] > [1] @mm + [0] = [c_15(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] >= [1] @m + [1] = [c_16(matrixMult^#(@acc, @m))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1] @m + [1] @ms + [1] >= [1] @ms + [1] = [c_17(matrixMultList^#(matrixMult(@acc, @m), @ms))] [matrixMultOld^#(@m1, @m2)] = [1] @m1 + [1] @m2 + [1] > [0] = [c_18(matrixMult'^#(@m1, transpose(@m2)))] [transpose'^#(@m)] = [1] @m + [1] >= [1] @m + [1] = [c_19(transAcc^#(@m, makeBase(@m)))] Consider the set of all dependency pairs DPs: { 1: attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , 2: attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , 3: attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , 4: lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , 5: lineMult#1^#(::(@x, @xs), @l) -> c_5(lineMult^#(@l, @xs)) , 6: matrixMult^#(@m1, @m2) -> c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 7: matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2))) , 8: matrixMult'^#(@m1, @m2) -> c_8(matrixMult'#1^#(@m1, @m2)) , 9: transAcc^#(@m, @base) -> c_9(transAcc#1^#(@m, @base)) , 10: transAcc#1^#(::(@l, @m'), @base) -> c_10(attach^#(@l, transAcc(@m', @base))) , 11: transAcc#1^#(::(@l, @m'), @base) -> c_11(transAcc^#(@m', @base)) , 12: matrixMult'#1^#(::(@l, @ls), @m2) -> c_12(lineMult^#(@l, @m2)) , 13: matrixMult'#1^#(::(@l, @ls), @m2) -> c_13(matrixMult'^#(@ls, @m2)) , 14: matrixMult3^#(@m1, @m2, @m3) -> c_14(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 15: matrixMultList^#(@acc, @mm) -> c_15(matrixMultList#1^#(@mm, @acc)) , 16: matrixMultList#1^#(::(@m, @ms), @acc) -> c_16(matrixMult^#(@acc, @m)) , 17: matrixMultList#1^#(::(@m, @ms), @acc) -> c_17(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 18: matrixMultOld^#(@m1, @m2) -> c_18(matrixMult'^#(@m1, transpose(@m2))) , 19: transpose'^#(@m) -> c_19(transAcc^#(@m, makeBase(@m))) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,6,10,15,18}. These cover all (indirect) predecessors of dependency pairs {1,2,3,6,7,10,14,15,16,17,18,19}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(lineMult^#(@l, @xs)) } Weak DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , matrixMult^#(@m1, @m2) -> c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> c_8(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_9(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_10(attach^#(@l, transAcc(@m', @base))) , transAcc#1^#(::(@l, @m'), @base) -> c_11(transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_12(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_13(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_14(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_15(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_16(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_17(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_18(matrixMult'^#(@m1, transpose(@m2))) , transpose'^#(@m) -> c_19(transAcc^#(@m, makeBase(@m))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , matrixMult^#(@m1, @m2) -> c_7(transAcc^#(@m2, makeBase(@m2))) , transAcc^#(@m, @base) -> c_9(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_10(attach^#(@l, transAcc(@m', @base))) , transAcc#1^#(::(@l, @m'), @base) -> c_11(transAcc^#(@m', @base)) , transpose'^#(@m) -> c_19(transAcc^#(@m, makeBase(@m))) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(lineMult^#(@l, @xs)) } Weak DPs: { matrixMult^#(@m1, @m2) -> c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_8(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_12(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_13(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_14(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_15(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_16(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_17(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_18(matrixMult'^#(@m1, transpose(@m2))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 1: lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) } Trs: { attach#2(nil(), @x, @xs) -> nil() , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transpose#1(nil(), @m) -> nil() , transpose#3(nil(), @l) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_8) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0 0] x1 + [0] [1 1] [0] [#neg](x1) = [0 0] x1 + [0] [1 1] [0] [#pos](x1) = [0 1] x1 + [0] [1 0] [0] [#s](x1) = [1 0] x1 + [0] [0 1] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [1 0] x2 + [0] [0 1] [0] [#add](x1, x2) = [1 0] x2 + [0] [1 1] [0] [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [0] [nil] = [0] [0] [lineMult](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [1 1] [0] [lineMult#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [1 1] [1 0] [0] [mult](x1, x2) = [1 0] x1 + [0 1] x2 + [0] [1 0] [0 1] [0] [makeBase](x1) = [1 0] x1 + [0] [1 0] [0] [makeBase#1](x1) = [1 0] x1 + [0] [1 0] [0] [mkBase](x1) = [0 0] x1 + [0] [1 1] [0] [matrixMult](x1, x2) = [1 0] x1 + [0] [0 0] [0] [transAcc](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [matrixMult'](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [1 0] [0 0] [0] [matrixMult'#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [1 0] [0] [transpose](x1) = [1 1] x1 + [1] [1 1] [0] [mkBase#1](x1) = [0 0] x1 + [0] [1 1] [0] [mult#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [1 1] [0 1] [0] [mult#2](x1, x2, x3) = [0 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [split](x1) = [0 1] x1 + [0] [1 0] [1] [split#1](x1) = [0 1] x1 + [0] [1 0] [1] [split#2](x1, x2) = [0 0] x1 + [0 1] x2 + [1] [1 1] [1 0] [1] [tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0] [1 0] [1 1] [1] [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0 0] x3 + [1] [0 1] [1 1] [1 1] [1] [transAcc#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [transpose#1](x1, x2) = [0 0] x1 + [1 1] x2 + [1] [0 1] [1 0] [0] [transpose#2](x1) = [1 1] x1 + [0] [0 1] [0] [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [1] [1 1] [0 0] [1] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [1 1] x1 + [0] [1 0] [0] [#natadd](x1, x2) = [1 0] x2 + [0] [1 0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [0 1] x2 + [1] [0 0] [0] [lineMult#1^#](x1, x2) = [0 1] x1 + [0] [0 0] [0] [mult^#](x1, x2) = [0] [0] [mult#1^#](x1, x2) = [0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [1 1] x2 + [1] [1 0] [0] [matrixMult'^#](x1, x2) = [0 0] x1 + [0 1] x2 + [1] [0 1] [0 0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [0 1] x2 + [1] [0 0] [0] [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 1] x3 + [1] [1 1] [1 1] [1 1] [1] [matrixMultList^#](x1, x2) = [1 0] x2 + [1] [0 0] [0] [matrixMultList#1^#](x1, x2) = [1 0] x1 + [1] [0 0] [0] [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1] [1 1] [1 1] [1] [transpose^#](x1) = [0] [0] [transpose#1^#](x1, x2) = [0] [0] [mult#2^#](x1, x2, x3) = [0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0] [0] [transpose#3^#](x1, x2) = [0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_1](x1) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1, x2) = [0] [0] [c] = [0] [0] [c_1](x1) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [1 1] x1 + [0] [0 0] [0] [c_5](x1) = [1 1] x1 + [0] [0 0] [0] [c_6](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [1 1] x1 + [0] [0 0] [0] [c_9](x1) = [0] [0] [c_10](x1) = [0] [0] [c_11](x1) = [0] [0] [c_12](x1) = [1 1] x1 + [0] [0 0] [0] [c_13](x1) = [1 0] x1 + [0] [0 0] [0] [c_14](x1) = [1 0] x1 + [0] [0 0] [1] [c_15](x1) = [1 0] x1 + [0] [0 0] [0] [c_16](x1) = [1 0] x1 + [0] [0 0] [0] [c_17](x1) = [1 0] x1 + [0] [0 0] [0] [c_18](x1) = [1 0] x1 + [0] [0 0] [1] [c_19](x1) = [0] [0] This order satisfies following ordering constraints [attach(@line, @m)] = [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] >= [1 1] @line + [1 0] @m + [0] [0 0] [0 1] [0] = [attach#1(@line, @m)] [attach#1(::(@x, @xs), @m)] = [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [0] >= [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [0] = [attach#2(@m, @x, @xs)] [attach#1(nil(), @m)] = [1 0] @m + [0] [0 1] [0] >= [0] [0] = [nil()] [attach#2(::(@l, @ls), @x, @xs)] = [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [1] >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 0] [1] = [::(::(@x, @l), attach(@xs, @ls))] [attach#2(nil(), @x, @xs)] = [1 1] @x + [1 1] @xs + [1] [0 0] [0 0] [0] > [0] [0] = [nil()] [makeBase(@m)] = [1 0] @m + [0] [1 0] [0] >= [1 0] @m + [0] [1 0] [0] = [makeBase#1(@m)] [makeBase#1(::(@l, @m'))] = [1 1] @l + [1 0] @m' + [0] [1 1] [1 0] [0] >= [0 0] @l + [0] [1 1] [0] = [mkBase(@l)] [makeBase#1(nil())] = [0] [0] >= [0] [0] = [nil()] [mkBase(@m)] = [0 0] @m + [0] [1 1] [0] >= [0 0] @m + [0] [1 1] [0] = [mkBase#1(@m)] [transAcc(@m, @base)] = [1 0] @base + [1 1] @m + [0] [0 1] [0 1] [0] >= [1 0] @base + [1 1] @m + [0] [0 1] [0 1] [0] = [transAcc#1(@m, @base)] [transpose(@m)] = [1 1] @m + [1] [1 1] [0] >= [1 1] @m + [1] [1 1] [0] = [transpose#1(@m, @m)] [mkBase#1(::(@l, @m'))] = [0 0] @l + [0 0] @m' + [0] [1 1] [1 1] [1] >= [0 0] @m' + [0] [1 1] [1] = [::(nil(), mkBase(@m'))] [mkBase#1(nil())] = [0] [0] >= [0] [0] = [nil()] [split(@m)] = [0 1] @m + [0] [1 0] [1] >= [0 1] @m + [0] [1 0] [1] = [split#1(@m)] [split#1(::(@l, @ls))] = [0 0] @l + [0 1] @ls + [1] [1 1] [1 0] [1] >= [0 0] @l + [0 1] @ls + [1] [1 1] [1 0] [1] = [split#2(@l, @ls)] [split#1(nil())] = [0] [1] >= [0] [1] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [0 1] @ls + [0 0] @x + [0 0] @xs + [1] [1 0] [1 1] [1 1] [2] >= [0 1] @ls + [0 0] @x + [0 0] @xs + [1] [1 0] [1 1] [1 1] [2] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [0 1] @ls + [1] [1 0] [1] > [0] [1] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [1] [1 1] [1 1] [1 1] [1 0] [2] >= [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [1] [1 1] [1 1] [1 1] [1 0] [2] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transAcc#1(::(@l, @m'), @base)] = [1 0] @base + [1 1] @l + [1 1] @m' + [1] [0 1] [0 0] [0 1] [1] > [1 0] @base + [1 1] @l + [1 1] @m' + [0] [0 1] [0 0] [0 1] [0] = [attach(@l, transAcc(@m', @base))] [transAcc#1(nil(), @base)] = [1 0] @base + [0] [0 1] [0] >= [1 0] @base + [0] [0 1] [0] = [@base] [transpose#1(::(@xs, @xss), @m)] = [1 1] @m + [0 0] @xss + [1] [1 0] [0 1] [1] >= [1 1] @m + [1] [1 0] [1] = [transpose#2(split(@m))] [transpose#1(nil(), @m)] = [1 1] @m + [1] [1 0] [0] > [0] [0] = [nil()] [transpose#2(tuple#2(@l, @m'))] = [1 1] @l + [1 1] @m' + [1] [1 0] [1 1] [1] >= [1 1] @l + [1 1] @m' + [1] [0 0] [1 1] [1] = [transpose#3(@m', @l)] [transpose#3(::(@y, @ys), @l)] = [1 1] @l + [1 1] @y + [1 1] @ys + [2] [0 0] [1 1] [1 1] [2] >= [1 1] @l + [1 1] @y + [1 1] @ys + [2] [0 0] [1 1] [1 1] [2] = [::(@l, transpose(::(@y, @ys)))] [transpose#3(nil(), @l)] = [1 1] @l + [1] [0 0] [1] > [0] [0] = [nil()] [lineMult^#(@l, @m2)] = [0 1] @m2 + [1] [0 0] [0] > [0 1] @m2 + [0] [0 0] [0] = [c_4(lineMult#1^#(@m2, @l))] [lineMult#1^#(::(@x, @xs), @l)] = [0 1] @xs + [1] [0 0] [0] >= [0 1] @xs + [1] [0 0] [0] = [c_5(lineMult^#(@l, @xs))] [matrixMult^#(@m1, @m2)] = [1 1] @m2 + [1] [1 0] [0] >= [1 1] @m2 + [1] [0 0] [0] = [c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))] [matrixMult'^#(@m1, @m2)] = [0 0] @m1 + [0 1] @m2 + [1] [0 1] [0 0] [0] >= [0 1] @m2 + [1] [0 0] [0] = [c_8(matrixMult'#1^#(@m1, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 1] @m2 + [1] [0 0] [0] >= [0 1] @m2 + [1] [0 0] [0] = [c_12(lineMult^#(@l, @m2))] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 1] @m2 + [1] [0 0] [0] >= [0 1] @m2 + [1] [0 0] [0] = [c_13(matrixMult'^#(@ls, @m2))] [matrixMult3^#(@m1, @m2, @m3)] = [1 0] @m1 + [1 0] @m2 + [1 1] @m3 + [1] [1 1] [1 1] [1 1] [1] >= [1 1] @m3 + [1] [0 0] [1] = [c_14(matrixMult^#(matrixMult(@m1, @m2), @m3))] [matrixMultList^#(@acc, @mm)] = [1 0] @mm + [1] [0 0] [0] >= [1 0] @mm + [1] [0 0] [0] = [c_15(matrixMultList#1^#(@mm, @acc))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 0] @ms + [1] [0 0] [0 0] [0] >= [1 1] @m + [1] [0 0] [0] = [c_16(matrixMult^#(@acc, @m))] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 0] @ms + [1] [0 0] [0 0] [0] >= [1 0] @ms + [1] [0 0] [0] = [c_17(matrixMultList^#(matrixMult(@acc, @m), @ms))] [matrixMultOld^#(@m1, @m2)] = [1 0] @m1 + [1 1] @m2 + [1] [1 1] [1 1] [1] >= [1 1] @m2 + [1] [0 0] [1] = [c_18(matrixMult'^#(@m1, transpose(@m2)))] Consider the set of all dependency pairs DPs: { 1: lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , 2: lineMult#1^#(::(@x, @xs), @l) -> c_5(lineMult^#(@l, @xs)) , 3: matrixMult^#(@m1, @m2) -> c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , 4: matrixMult'^#(@m1, @m2) -> c_8(matrixMult'#1^#(@m1, @m2)) , 5: matrixMult'#1^#(::(@l, @ls), @m2) -> c_12(lineMult^#(@l, @m2)) , 6: matrixMult'#1^#(::(@l, @ls), @m2) -> c_13(matrixMult'^#(@ls, @m2)) , 7: matrixMult3^#(@m1, @m2, @m3) -> c_14(matrixMult^#(matrixMult(@m1, @m2), @m3)) , 8: matrixMultList^#(@acc, @mm) -> c_15(matrixMultList#1^#(@mm, @acc)) , 9: matrixMultList#1^#(::(@m, @ms), @acc) -> c_16(matrixMult^#(@acc, @m)) , 10: matrixMultList#1^#(::(@m, @ms), @acc) -> c_17(matrixMultList^#(matrixMult(@acc, @m), @ms)) , 11: matrixMultOld^#(@m1, @m2) -> c_18(matrixMult'^#(@m1, transpose(@m2))) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {1}. These cover all (indirect) predecessors of dependency pairs {1,2,7,11}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(lineMult^#(@l, @xs)) , matrixMult^#(@m1, @m2) -> c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_8(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_12(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_13(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_14(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_15(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_16(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_17(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_18(matrixMult'^#(@m1, transpose(@m2))) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(lineMult^#(@l, @xs)) , matrixMult^#(@m1, @m2) -> c_6(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) , matrixMult'^#(@m1, @m2) -> c_8(matrixMult'#1^#(@m1, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_12(lineMult^#(@l, @m2)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_13(matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> c_14(matrixMult^#(matrixMult(@m1, @m2), @m3)) , matrixMultList^#(@acc, @mm) -> c_15(matrixMultList#1^#(@mm, @acc)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_16(matrixMult^#(@acc, @m)) , matrixMultList#1^#(::(@m, @ms), @acc) -> c_17(matrixMultList^#(matrixMult(@acc, @m), @ms)) , matrixMultOld^#(@m1, @m2) -> c_18(matrixMult'^#(@m1, transpose(@m2))) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { attach^#(@line, @m) -> attach#1^#(@line, @m) , attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) , attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) , lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) , lineMult#1^#(::(@x, @xs), @l) -> lineMult^#(@l, @xs) , lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2)) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) , transAcc#1^#(::(@l, @m'), @base) -> attach^#(@l, transAcc(@m', @base)) , transAcc#1^#(::(@l, @m'), @base) -> transAcc^#(@m', @base) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { attach^#(@line, @m) -> attach#1^#(@line, @m) , attach#1^#(::(@x, @xs), @m) -> attach#2^#(@m, @x, @xs) , attach#2^#(::(@l, @ls), @x, @xs) -> attach^#(@xs, @ls) , matrixMult^#(@m1, @m2) -> transAcc^#(@m2, makeBase(@m2)) , transAcc^#(@m, @base) -> transAcc#1^#(@m, @base) , transAcc#1^#(::(@l, @m'), @base) -> attach^#(@l, transAcc(@m', @base)) , transAcc#1^#(::(@l, @m'), @base) -> transAcc^#(@m', @base) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak DPs: { lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) , lineMult#1^#(::(@x, @xs), @l) -> lineMult^#(@l, @xs) , lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 3: mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Trs: { attach#2(nil(), @x, @xs) -> nil() , makeBase#1(nil()) -> nil() , mkBase#1(nil()) -> nil() , transpose#1(nil(), @m) -> nil() , transpose#3(nil(), @l) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_23) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0] [0] [#neg](x1) = [0 1] x1 + [0] [0 1] [0] [#pos](x1) = [0 1] x1 + [0] [0 1] [0] [#s](x1) = [0 0] x1 + [0] [0 1] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [1 0] x2 + [0] [0 0] [0] [#add](x1, x2) = [1 0] x2 + [0] [1 1] [0] [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 1] [0 1] [1] [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 1] [1] [nil] = [0] [0] [lineMult](x1, x2) = [0] [1] [lineMult#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [1 0] [1] [mult](x1, x2) = [0] [0] [makeBase](x1) = [0 0] x1 + [1] [1 1] [1] [makeBase#1](x1) = [0 0] x1 + [1] [1 1] [0] [mkBase](x1) = [0 0] x1 + [1] [0 1] [0] [matrixMult](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [0 0] [1 1] [1] [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [1 1] [1 1] [0] [matrixMult'](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [0 0] [1 0] [0] [matrixMult'#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 1] [0] [transpose](x1) = [1 1] x1 + [1] [1 0] [0] [mkBase#1](x1) = [0 0] x1 + [1] [0 1] [0] [mult#1](x1, x2) = [0] [0] [mult#2](x1, x2, x3) = [1 0] x2 + [1 0] x3 + [0] [1 0] [1 0] [0] [split](x1) = [1 0] x1 + [0] [0 1] [0] [split#1](x1) = [1 0] x1 + [0] [0 1] [0] [split#2](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [tuple#2](x1, x2) = [1 0] x1 + [1 1] x2 + [0] [0 1] [0 0] [0] [split#3](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [1] [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [1 1] [1 1] [0] [transpose#1](x1, x2) = [1 1] x2 + [1] [1 0] [0] [transpose#2](x1) = [1 1] x1 + [1] [1 0] [0] [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [1] [1 1] [0 0] [0] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [0 0] x1 + [0] [1 0] [0] [#natadd](x1, x2) = [1 0] x2 + [0] [0 0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [lineMult#1^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [mult^#](x1, x2) = [0 1] x2 + [0] [0 0] [0] [mult#1^#](x1, x2) = [0 1] x2 + [0] [0 0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [1 0] x2 + [1] [0 0] [0] [matrixMult'^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 0] x3 + [1] [1 1] [1 1] [1 1] [1] [matrixMultList^#](x1, x2) = [1 0] x2 + [1] [0 0] [1] [matrixMultList#1^#](x1, x2) = [1 0] x1 + [1] [0 0] [1] [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1] [1 1] [1 1] [1] [transpose^#](x1) = [0] [0] [transpose#1^#](x1, x2) = [0] [0] [mult#2^#](x1, x2, x3) = [0 1] x1 + [0 0] x3 + [0] [1 0] [1 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0] [0] [transpose#3^#](x1, x2) = [0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_6](x1) = [1 1] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_23](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [attach(@line, @m)] = [1 1] @line + [1 0] @m + [0] [0 1] [0 1] [1] >= [1 1] @line + [1 0] @m + [0] [0 1] [0 1] [0] = [attach#1(@line, @m)] [attach#1(::(@x, @xs), @m)] = [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 1] [1] >= [1 0] @m + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 1] [1] = [attach#2(@m, @x, @xs)] [attach#1(nil(), @m)] = [1 0] @m + [0] [0 1] [0] >= [0] [0] = [nil()] [attach#2(::(@l, @ls), @x, @xs)] = [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 1] [2] >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [0 0] [0 1] [2] = [::(::(@x, @l), attach(@xs, @ls))] [attach#2(nil(), @x, @xs)] = [1 1] @x + [1 1] @xs + [1] [0 0] [0 1] [1] > [0] [0] = [nil()] [makeBase(@m)] = [0 0] @m + [1] [1 1] [1] >= [0 0] @m + [1] [1 1] [0] = [makeBase#1(@m)] [makeBase#1(::(@l, @m'))] = [0 0] @l + [0 0] @m' + [1] [1 1] [1 1] [1] >= [0 0] @l + [1] [0 1] [0] = [mkBase(@l)] [makeBase#1(nil())] = [1] [0] > [0] [0] = [nil()] [mkBase(@m)] = [0 0] @m + [1] [0 1] [0] >= [0 0] @m + [1] [0 1] [0] = [mkBase#1(@m)] [transAcc(@m, @base)] = [1 0] @base + [1 0] @m + [0] [1 1] [1 1] [0] >= [1 0] @base + [1 0] @m + [0] [1 1] [1 1] [0] = [transAcc#1(@m, @base)] [transpose(@m)] = [1 1] @m + [1] [1 0] [0] >= [1 1] @m + [1] [1 0] [0] = [transpose#1(@m, @m)] [mkBase#1(::(@l, @m'))] = [0 0] @m' + [1] [0 1] [1] >= [0 0] @m' + [1] [0 1] [1] = [::(nil(), mkBase(@m'))] [mkBase#1(nil())] = [1] [0] > [0] [0] = [nil()] [split(@m)] = [1 0] @m + [0] [0 1] [0] >= [1 0] @m + [0] [0 1] [0] = [split#1(@m)] [split#1(::(@l, @ls))] = [1 1] @l + [1 0] @ls + [0] [0 0] [0 1] [1] >= [1 1] @l + [1 0] @ls + [0] [0 0] [0 1] [1] = [split#2(@l, @ls)] [split#1(nil())] = [0] [0] >= [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [1] >= [1 0] @ls + [1 1] @x + [1 1] @xs + [1] [0 1] [0 0] [0 0] [1] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [1 0] @ls + [0] [0 1] [1] >= [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1] [0 0] [0 0] [0 0] [0 1] [1] >= [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1] [0 0] [0 0] [0 0] [0 1] [1] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transAcc#1(::(@l, @m'), @base)] = [1 0] @base + [1 1] @l + [1 0] @m' + [0] [1 1] [1 1] [1 1] [1] >= [1 0] @base + [1 1] @l + [1 0] @m' + [0] [1 1] [0 1] [1 1] [1] = [attach(@l, transAcc(@m', @base))] [transAcc#1(nil(), @base)] = [1 0] @base + [0] [1 1] [0] >= [1 0] @base + [0] [0 1] [0] = [@base] [transpose#1(::(@xs, @xss), @m)] = [1 1] @m + [1] [1 0] [0] >= [1 1] @m + [1] [1 0] [0] = [transpose#2(split(@m))] [transpose#1(nil(), @m)] = [1 1] @m + [1] [1 0] [0] > [0] [0] = [nil()] [transpose#2(tuple#2(@l, @m'))] = [1 1] @l + [1 1] @m' + [1] [1 0] [1 1] [0] >= [1 1] @l + [1 1] @m' + [1] [0 0] [1 1] [0] = [transpose#3(@m', @l)] [transpose#3(::(@y, @ys), @l)] = [1 1] @l + [1 1] @y + [1 1] @ys + [2] [0 0] [1 1] [1 1] [1] >= [1 1] @l + [1 1] @y + [1 1] @ys + [2] [0 0] [1 1] [1 0] [1] = [::(@l, transpose(::(@y, @ys)))] [transpose#3(nil(), @l)] = [1 1] @l + [1] [0 0] [0] > [0] [0] = [nil()] [lineMult^#(@l, @m2)] = [1 0] @m2 + [0] [0 0] [0] >= [1 0] @m2 + [0] [0 0] [0] = [lineMult#1^#(@m2, @l)] [lineMult#1^#(::(@x, @xs), @l)] = [1 1] @x + [1 0] @xs + [0] [0 0] [0 0] [0] >= [1 0] @xs + [0] [0 0] [0] = [lineMult^#(@l, @xs)] [lineMult#1^#(::(@x, @xs), @l)] = [1 1] @x + [1 0] @xs + [0] [0 0] [0 0] [0] >= [0 1] @x + [0] [0 0] [0] = [mult^#(@l, @x)] [mult^#(@l1, @l2)] = [0 1] @l2 + [0] [0 0] [0] >= [0 1] @l2 + [0] [0 0] [0] = [c_6(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [0 1] @l2 + [0] [0 0] [0] >= [0 1] @l2 + [0] [0 0] [0] = [c_7(mult#2^#(@l2, @x, @xs))] [matrixMult^#(@m1, @m2)] = [1 0] @m2 + [1] [0 0] [0] >= [1 0] @m2 + [1] [0 0] [0] = [matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))] [matrixMult'^#(@m1, @m2)] = [1 0] @m2 + [0] [0 0] [0] >= [1 0] @m2 + [0] [0 0] [0] = [matrixMult'#1^#(@m1, @m2)] [matrixMult'#1^#(::(@l, @ls), @m2)] = [1 0] @m2 + [0] [0 0] [0] >= [1 0] @m2 + [0] [0 0] [0] = [lineMult^#(@l, @m2)] [matrixMult'#1^#(::(@l, @ls), @m2)] = [1 0] @m2 + [0] [0 0] [0] >= [1 0] @m2 + [0] [0 0] [0] = [matrixMult'^#(@ls, @m2)] [matrixMult3^#(@m1, @m2, @m3)] = [1 0] @m1 + [1 0] @m2 + [1 0] @m3 + [1] [1 1] [1 1] [1 1] [1] >= [1 0] @m3 + [1] [0 0] [0] = [matrixMult^#(matrixMult(@m1, @m2), @m3)] [matrixMultList^#(@acc, @mm)] = [1 0] @mm + [1] [0 0] [1] >= [1 0] @mm + [1] [0 0] [1] = [matrixMultList#1^#(@mm, @acc)] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 0] @ms + [1] [0 0] [0 0] [1] >= [1 0] @m + [1] [0 0] [0] = [matrixMult^#(@acc, @m)] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 0] @ms + [1] [0 0] [0 0] [1] >= [1 0] @ms + [1] [0 0] [1] = [matrixMultList^#(matrixMult(@acc, @m), @ms)] [matrixMultOld^#(@m1, @m2)] = [1 0] @m1 + [1 1] @m2 + [1] [1 1] [1 1] [1] >= [1 1] @m2 + [1] [0 0] [0] = [matrixMult'^#(@m1, transpose(@m2))] [mult#2^#(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0 0] @y + [0 1] @ys + [1] [1 0] [1 1] [1 0] [0] > [0 1] @ys + [0] [0 0] [0] = [c_23(mult^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , 2: mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , 3: mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , 4: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) , 5: lineMult#1^#(::(@x, @xs), @l) -> lineMult^#(@l, @xs) , 6: lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , 7: matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , 8: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , 9: matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , 10: matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , 11: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , 12: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , 13: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , 14: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , 15: matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {3}. These cover all (indirect) predecessors of dependency pairs {3,11,15}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) } Weak DPs: { lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) , lineMult#1^#(::(@x, @xs), @l) -> lineMult^#(@l, @xs) , lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 5: lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , 11: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , 15: mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Trs: { attach#1(nil(), @m) -> nil() , attach#2(nil(), @x, @xs) -> nil() , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase#1(nil()) -> nil() , transpose#3(nil(), @l) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_23) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#0] = [0] [0] [#abs](x1) = [0] [0] [#neg](x1) = [0 0] x1 + [0] [1 1] [0] [#pos](x1) = [1 0] x1 + [0] [0 1] [0] [#s](x1) = [0 0] x1 + [0] [0 1] [0] [*](x1, x2) = [0] [0] [#mult](x1, x2) = [0] [0] [+](x1, x2) = [1 0] x2 + [0] [0 0] [0] [#add](x1, x2) = [1 0] x2 + [0] [1 1] [0] [attach](x1, x2) = [0 0] x1 + [1 0] x2 + [1] [1 1] [0 1] [0] [attach#1](x1, x2) = [0 0] x1 + [1 0] x2 + [1] [1 1] [0 1] [0] [::](x1, x2) = [0 0] x1 + [1 0] x2 + [1] [1 1] [0 1] [0] [attach#2](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0 0] x3 + [1] [0 1] [1 1] [1 1] [1] [nil] = [0] [0] [lineMult](x1, x2) = [0] [0] [lineMult#1](x1, x2) = [1 0] x1 + [0] [0 0] [1] [mult](x1, x2) = [0] [0] [makeBase](x1) = [1 1] x1 + [1] [1 0] [0] [makeBase#1](x1) = [1 1] x1 + [1] [1 0] [0] [mkBase](x1) = [1 0] x1 + [1] [0 0] [1] [matrixMult](x1, x2) = [1 0] x2 + [0] [0 0] [1] [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [matrixMult'](x1, x2) = [1 0] x2 + [0] [0 0] [1] [matrixMult'#1](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [1 1] [1 1] [1] [transpose](x1) = [1 1] x1 + [0] [1 1] [0] [mkBase#1](x1) = [1 0] x1 + [1] [0 0] [1] [mult#1](x1, x2) = [1 0] x2 + [0] [1 0] [0] [mult#2](x1, x2, x3) = [0 0] x2 + [1 0] x3 + [0] [1 1] [0 1] [0] [split](x1) = [0 1] x1 + [0] [1 0] [0] [split#1](x1) = [0 1] x1 + [0] [1 0] [0] [split#2](x1, x2) = [1 1] x1 + [0 1] x2 + [0] [0 0] [1 0] [1] [tuple#2](x1, x2) = [0 1] x1 + [1 1] x2 + [0] [1 0] [0 0] [0] [split#3](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1] [0 1] [0 0] [0 0] [1] [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [transpose#1](x1, x2) = [1 0] x1 + [0 1] x2 + [0] [0 0] [1 1] [0] [transpose#2](x1) = [1 0] x1 + [1] [1 1] [0] [transpose#3](x1, x2) = [1 1] x1 + [0 0] x2 + [1] [1 1] [1 1] [0] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [#natmult](x1, x2) = [0] [0] [#natadd](x1, x2) = [0] [0] [#abs^#](x1) = [0] [0] [*^#](x1, x2) = [0] [0] [#mult^#](x1, x2) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [attach^#](x1, x2) = [0] [0] [attach#1^#](x1, x2) = [0] [0] [attach#2^#](x1, x2, x3) = [0] [0] [lineMult^#](x1, x2) = [0 1] x2 + [1] [0 0] [0] [lineMult#1^#](x1, x2) = [0 1] x1 + [1] [0 0] [0] [mult^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [mult#1^#](x1, x2) = [1 0] x2 + [0] [0 0] [0] [makeBase^#](x1) = [0] [0] [makeBase#1^#](x1) = [0] [0] [mkBase^#](x1) = [0] [0] [mkBase#1^#](x1) = [0] [0] [matrixMult^#](x1, x2) = [1 1] x2 + [1] [0 0] [1] [matrixMult'^#](x1, x2) = [0 1] x2 + [1] [0 0] [1] [transAcc^#](x1, x2) = [0] [0] [transAcc#1^#](x1, x2) = [0] [0] [matrixMult'#1^#](x1, x2) = [0 1] x2 + [1] [0 0] [1] [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 1] x3 + [1] [1 1] [1 1] [1 1] [1] [matrixMultList^#](x1, x2) = [1 1] x2 + [1] [0 0] [1] [matrixMultList#1^#](x1, x2) = [1 1] x1 + [0] [0 0] [1] [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1] [1 1] [1 1] [1] [transpose^#](x1) = [0] [0] [transpose#1^#](x1, x2) = [0] [0] [mult#2^#](x1, x2, x3) = [1 0] x1 + [0] [0 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [transpose#2^#](x1) = [0] [0] [transpose#3^#](x1, x2) = [0] [0] [transpose'^#](x1) = [0] [0] [#natmult^#](x1, x2) = [0] [0] [#pred^#](x1) = [0] [0] [#succ^#](x1) = [0] [0] [#natadd^#](x1, x2) = [0] [0] [c_6](x1) = [1 1] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_23](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [attach(@line, @m)] = [0 0] @line + [1 0] @m + [1] [1 1] [0 1] [0] >= [0 0] @line + [1 0] @m + [1] [1 1] [0 1] [0] = [attach#1(@line, @m)] [attach#1(::(@x, @xs), @m)] = [1 0] @m + [0 0] @x + [0 0] @xs + [1] [0 1] [1 1] [1 1] [1] >= [1 0] @m + [0 0] @x + [0 0] @xs + [1] [0 1] [1 1] [1 1] [1] = [attach#2(@m, @x, @xs)] [attach#1(nil(), @m)] = [1 0] @m + [1] [0 1] [0] > [0] [0] = [nil()] [attach#2(::(@l, @ls), @x, @xs)] = [0 0] @l + [1 0] @ls + [0 0] @x + [0 0] @xs + [2] [1 1] [0 1] [1 1] [1 1] [1] >= [0 0] @l + [1 0] @ls + [0 0] @x + [0 0] @xs + [2] [1 1] [0 1] [1 1] [1 1] [1] = [::(::(@x, @l), attach(@xs, @ls))] [attach#2(nil(), @x, @xs)] = [0 0] @x + [0 0] @xs + [1] [1 1] [1 1] [1] > [0] [0] = [nil()] [makeBase(@m)] = [1 1] @m + [1] [1 0] [0] >= [1 1] @m + [1] [1 0] [0] = [makeBase#1(@m)] [makeBase#1(::(@l, @m'))] = [1 1] @l + [1 1] @m' + [2] [0 0] [1 0] [1] > [1 0] @l + [1] [0 0] [1] = [mkBase(@l)] [makeBase#1(nil())] = [1] [0] > [0] [0] = [nil()] [mkBase(@m)] = [1 0] @m + [1] [0 0] [1] >= [1 0] @m + [1] [0 0] [1] = [mkBase#1(@m)] [transAcc(@m, @base)] = [1 0] @base + [1 0] @m + [0] [0 1] [0 1] [0] >= [1 0] @base + [1 0] @m + [0] [0 1] [0 1] [0] = [transAcc#1(@m, @base)] [transpose(@m)] = [1 1] @m + [0] [1 1] [0] >= [1 1] @m + [0] [1 1] [0] = [transpose#1(@m, @m)] [mkBase#1(::(@l, @m'))] = [1 0] @m' + [2] [0 0] [1] >= [1 0] @m' + [2] [0 0] [1] = [::(nil(), mkBase(@m'))] [mkBase#1(nil())] = [1] [1] > [0] [0] = [nil()] [split(@m)] = [0 1] @m + [0] [1 0] [0] >= [0 1] @m + [0] [1 0] [0] = [split#1(@m)] [split#1(::(@l, @ls))] = [1 1] @l + [0 1] @ls + [0] [0 0] [1 0] [1] >= [1 1] @l + [0 1] @ls + [0] [0 0] [1 0] [1] = [split#2(@l, @ls)] [split#1(nil())] = [0] [0] >= [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [0 1] @ls + [1 1] @x + [1 1] @xs + [1] [1 0] [0 0] [0 0] [1] >= [0 1] @ls + [1 1] @x + [1 1] @xs + [1] [1 0] [0 0] [0 0] [1] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [0 1] @ls + [0] [1 0] [1] >= [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [1 1] @m' + [1 1] @x + [1 1] @xs + [0 1] @ys + [1] [0 0] [0 0] [0 0] [1 0] [1] >= [1 1] @m' + [1 1] @x + [1 1] @xs + [0 1] @ys + [1] [0 0] [0 0] [0 0] [1 0] [1] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transAcc#1(::(@l, @m'), @base)] = [1 0] @base + [0 0] @l + [1 0] @m' + [1] [0 1] [1 1] [0 1] [0] >= [1 0] @base + [0 0] @l + [1 0] @m' + [1] [0 1] [1 1] [0 1] [0] = [attach(@l, transAcc(@m', @base))] [transAcc#1(nil(), @base)] = [1 0] @base + [0] [0 1] [0] >= [1 0] @base + [0] [0 1] [0] = [@base] [transpose#1(::(@xs, @xss), @m)] = [0 1] @m + [1 0] @xss + [1] [1 1] [0 0] [0] >= [0 1] @m + [1] [1 1] [0] = [transpose#2(split(@m))] [transpose#1(nil(), @m)] = [0 1] @m + [0] [1 1] [0] >= [0] [0] = [nil()] [transpose#2(tuple#2(@l, @m'))] = [0 1] @l + [1 1] @m' + [1] [1 1] [1 1] [0] >= [0 0] @l + [1 1] @m' + [1] [1 1] [1 1] [0] = [transpose#3(@m', @l)] [transpose#3(::(@y, @ys), @l)] = [0 0] @l + [1 1] @y + [1 1] @ys + [2] [1 1] [1 1] [1 1] [1] >= [0 0] @l + [1 1] @y + [1 1] @ys + [2] [1 1] [1 1] [1 1] [1] = [::(@l, transpose(::(@y, @ys)))] [transpose#3(nil(), @l)] = [0 0] @l + [1] [1 1] [0] > [0] [0] = [nil()] [lineMult^#(@l, @m2)] = [0 1] @m2 + [1] [0 0] [0] >= [0 1] @m2 + [1] [0 0] [0] = [lineMult#1^#(@m2, @l)] [lineMult#1^#(::(@x, @xs), @l)] = [1 1] @x + [0 1] @xs + [1] [0 0] [0 0] [0] >= [0 1] @xs + [1] [0 0] [0] = [lineMult^#(@l, @xs)] [lineMult#1^#(::(@x, @xs), @l)] = [1 1] @x + [0 1] @xs + [1] [0 0] [0 0] [0] > [1 0] @x + [0] [0 0] [0] = [mult^#(@l, @x)] [mult^#(@l1, @l2)] = [1 0] @l2 + [0] [0 0] [0] >= [1 0] @l2 + [0] [0 0] [0] = [c_6(mult#1^#(@l1, @l2))] [mult#1^#(::(@x, @xs), @l2)] = [1 0] @l2 + [0] [0 0] [0] >= [1 0] @l2 + [0] [0 0] [0] = [c_7(mult#2^#(@l2, @x, @xs))] [matrixMult^#(@m1, @m2)] = [1 1] @m2 + [1] [0 0] [1] >= [1 1] @m2 + [1] [0 0] [1] = [matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))] [matrixMult'^#(@m1, @m2)] = [0 1] @m2 + [1] [0 0] [1] >= [0 1] @m2 + [1] [0 0] [1] = [matrixMult'#1^#(@m1, @m2)] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 1] @m2 + [1] [0 0] [1] >= [0 1] @m2 + [1] [0 0] [0] = [lineMult^#(@l, @m2)] [matrixMult'#1^#(::(@l, @ls), @m2)] = [0 1] @m2 + [1] [0 0] [1] >= [0 1] @m2 + [1] [0 0] [1] = [matrixMult'^#(@ls, @m2)] [matrixMult3^#(@m1, @m2, @m3)] = [1 0] @m1 + [1 0] @m2 + [1 1] @m3 + [1] [1 1] [1 1] [1 1] [1] >= [1 1] @m3 + [1] [0 0] [1] = [matrixMult^#(matrixMult(@m1, @m2), @m3)] [matrixMultList^#(@acc, @mm)] = [1 1] @mm + [1] [0 0] [1] > [1 1] @mm + [0] [0 0] [1] = [matrixMultList#1^#(@mm, @acc)] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 1] @ms + [1] [0 0] [0 0] [1] >= [1 1] @m + [1] [0 0] [1] = [matrixMult^#(@acc, @m)] [matrixMultList#1^#(::(@m, @ms), @acc)] = [1 1] @m + [1 1] @ms + [1] [0 0] [0 0] [1] >= [1 1] @ms + [1] [0 0] [1] = [matrixMultList^#(matrixMult(@acc, @m), @ms)] [matrixMultOld^#(@m1, @m2)] = [1 0] @m1 + [1 1] @m2 + [1] [1 1] [1 1] [1] >= [1 1] @m2 + [1] [0 0] [1] = [matrixMult'^#(@m1, transpose(@m2))] [mult#2^#(::(@y, @ys), @x, @xs)] = [1 0] @ys + [1] [0 0] [0] > [1 0] @ys + [0] [0 0] [0] = [c_23(mult^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , 2: mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , 3: lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) , 4: lineMult#1^#(::(@x, @xs), @l) -> lineMult^#(@l, @xs) , 5: lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , 6: matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , 7: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , 8: matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , 9: matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , 10: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , 11: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , 12: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , 13: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , 14: matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , 15: mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {5,11,15}. These cover all (indirect) predecessors of dependency pairs {1,2,5,6,10,11,12,13,14,15}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) , lineMult#1^#(::(@x, @xs), @l) -> lineMult^#(@l, @xs) , lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { lineMult^#(@l, @m2) -> lineMult#1^#(@m2, @l) , lineMult#1^#(::(@x, @xs), @l) -> lineMult^#(@l, @xs) , lineMult#1^#(::(@x, @xs), @l) -> mult^#(@l, @x) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , matrixMult^#(@m1, @m2) -> matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))) , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2) , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded Wall-time: 5.030167s CPU-time: 35.582s Wall-time: 3.879536s CPU-time: 27.159s S) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) } Weak DPs: { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m)) , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs)) , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l)) , lineMult#1^#(::(@x, @xs), @l) -> c_5(mult^#(@l, @x), lineMult^#(@l, @xs)) , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2)) , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs)) , makeBase^#(@m) -> c_8(makeBase#1^#(@m)) , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l)) , mkBase^#(@m) -> c_10(mkBase#1^#(@m)) , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m')) , matrixMult^#(@m1, @m2) -> c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))), transAcc^#(@m2, makeBase(@m2)), makeBase^#(@m2)) , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2)) , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base)) , transAcc#1^#(::(@l, @m'), @base) -> c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) , matrixMult'#1^#(::(@l, @ls), @m2) -> c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(matrixMult(@m1, @m2), @m3) , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m) , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMultList^#(matrixMult(@acc, @m), @ms) , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys)) , transpose'^#(@m) -> makeBase^#(@m) , transpose'^#(@m) -> transAcc^#(@m, makeBase(@m)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) } Weak DPs: { matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) , transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Consider the dependency graph 1: split^#(@m) -> c_24(split#1^#(@m)) -->_1 split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) :2 2: split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) -->_1 split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) :3 3: split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) -->_1 split^#(@m) -> c_24(split#1^#(@m)) :1 4: matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) -->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :5 5: transpose^#(@m) -> transpose#1^#(@m, @m) -->_1 transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) :7 -->_1 transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) :6 6: transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) -->_1 split^#(@m) -> c_24(split#1^#(@m)) :1 7: transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) -->_1 transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) :8 8: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) -->_1 transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) :9 9: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) -->_1 transpose^#(@m) -> transpose#1^#(@m, @m) :5 Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { matrixMultOld^#(@m1, @m2) -> transpose^#(@m2) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) } Weak DPs: { transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) } Weak Trs: { #abs(#0()) -> #0() , #abs(#neg(@x)) -> #pos(@x) , #abs(#pos(@x)) -> #pos(@x) , #abs(#s(@x)) -> #pos(#s(@x)) , *(@x, @y) -> #mult(@x, @y) , #mult(#0(), #0()) -> #0() , #mult(#0(), #neg(@y)) -> #0() , #mult(#0(), #pos(@y)) -> #0() , #mult(#neg(@x), #0()) -> #0() , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #0()) -> #0() , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) , +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , attach(@line, @m) -> attach#1(@line, @m) , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs) , attach#1(nil(), @m) -> nil() , attach#2(::(@l, @ls), @x, @xs) -> ::(::(@x, @l), attach(@xs, @ls)) , attach#2(nil(), @x, @xs) -> nil() , lineMult(@l, @m2) -> lineMult#1(@m2, @l) , lineMult#1(::(@x, @xs), @l) -> ::(mult(@l, @x), lineMult(@l, @xs)) , lineMult#1(nil(), @l) -> nil() , mult(@l1, @l2) -> mult#1(@l1, @l2) , makeBase(@m) -> makeBase#1(@m) , makeBase#1(::(@l, @m')) -> mkBase(@l) , makeBase#1(nil()) -> nil() , mkBase(@m) -> mkBase#1(@m) , matrixMult(@m1, @m2) -> matrixMult'(@m1, transAcc(@m2, makeBase(@m2))) , transAcc(@m, @base) -> transAcc#1(@m, @base) , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2) , matrixMult'#1(::(@l, @ls), @m2) -> ::(lineMult(@l, @m2), matrixMult'(@ls, @m2)) , matrixMult'#1(nil(), @m2) -> nil() , transpose(@m) -> transpose#1(@m, @m) , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m')) , mkBase#1(nil()) -> nil() , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs) , mult#1(nil(), @l2) -> #abs(#0()) , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys)) , mult#2(nil(), @x, @xs) -> #abs(#0()) , split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) , transAcc#1(::(@l, @m'), @base) -> attach(@l, transAcc(@m', @base)) , transAcc#1(nil(), @base) -> @base , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) , transpose#1(nil(), @m) -> nil() , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l) , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys))) , transpose#3(nil(), @l) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #natmult(#0(), @y) -> #0() , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y)) , #natadd(#0(), @y) -> @y , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We replace rewrite rules by usable rules: Weak Usable Rules: { split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) } Weak DPs: { transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) } Weak Trs: { split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 2: split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , 5: transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) } Trs: { split#1(::(@l, @ls)) -> split#2(@l, @ls) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_24) = {1}, Uargs(c_25) = {1}, Uargs(c_26) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#0] = [0] [#abs](x1) = [0] [#neg](x1) = [0] [#pos](x1) = [0] [#s](x1) = [0] [*](x1, x2) = [0] [#mult](x1, x2) = [0] [+](x1, x2) = [0] [#add](x1, x2) = [0] [attach](x1, x2) = [0] [attach#1](x1, x2) = [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [attach#2](x1, x2, x3) = [0] [nil] = [0] [lineMult](x1, x2) = [0] [lineMult#1](x1, x2) = [0] [mult](x1, x2) = [0] [makeBase](x1) = [0] [makeBase#1](x1) = [0] [mkBase](x1) = [0] [matrixMult](x1, x2) = [0] [transAcc](x1, x2) = [0] [matrixMult'](x1, x2) = [0] [matrixMult'#1](x1, x2) = [0] [transpose](x1) = [0] [mkBase#1](x1) = [0] [mult#1](x1, x2) = [0] [mult#2](x1, x2, x3) = [0] [split](x1) = [1] x1 + [0] [split#1](x1) = [1] x1 + [0] [split#2](x1, x2) = [1] x1 + [1] x2 + [0] [tuple#2](x1, x2) = [1] x2 + [0] [split#3](x1, x2, x3) = [1] x1 + [1] x3 + [1] [transAcc#1](x1, x2) = [0] [transpose#1](x1, x2) = [0] [transpose#2](x1) = [0] [transpose#3](x1, x2) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [#natmult](x1, x2) = [0] [#natadd](x1, x2) = [0] [#abs^#](x1) = [0] [*^#](x1, x2) = [0] [#mult^#](x1, x2) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [attach^#](x1, x2) = [0] [attach#1^#](x1, x2) = [0] [attach#2^#](x1, x2, x3) = [0] [lineMult^#](x1, x2) = [0] [lineMult#1^#](x1, x2) = [0] [mult^#](x1, x2) = [0] [mult#1^#](x1, x2) = [0] [makeBase^#](x1) = [0] [makeBase#1^#](x1) = [0] [mkBase^#](x1) = [0] [mkBase#1^#](x1) = [0] [matrixMult^#](x1, x2) = [0] [matrixMult'^#](x1, x2) = [0] [transAcc^#](x1, x2) = [0] [transAcc#1^#](x1, x2) = [0] [matrixMult'#1^#](x1, x2) = [0] [matrixMult3^#](x1, x2, x3) = [0] [matrixMultList^#](x1, x2) = [0] [matrixMultList#1^#](x1, x2) = [0] [matrixMultOld^#](x1, x2) = [0] [transpose^#](x1) = [1] x1 + [1] [transpose#1^#](x1, x2) = [1] x2 + [1] [mult#2^#](x1, x2, x3) = [0] [split^#](x1) = [1] x1 + [0] [split#1^#](x1) = [1] x1 + [0] [split#2^#](x1, x2) = [1] x2 + [0] [split#3^#](x1, x2, x3) = [0] [transpose#2^#](x1) = [1] x1 + [1] [transpose#3^#](x1, x2) = [1] x1 + [1] [transpose'^#](x1) = [0] [#natmult^#](x1, x2) = [0] [#pred^#](x1) = [0] [#succ^#](x1) = [0] [#natadd^#](x1, x2) = [0] [c_1](x1) = [0] [c_2](x1) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1, x2) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1) = [0] [c_9](x1) = [0] [c_10](x1) = [0] [c_11](x1) = [0] [c_12](x1, x2, x3) = [0] [c_13](x1) = [0] [c_14](x1) = [0] [c_15](x1, x2) = [0] [c_16](x1, x2) = [0] [c_23](x1) = [0] [c_24](x1) = [1] x1 + [0] [c_25](x1) = [1] x1 + [0] [c_26](x1) = [1] x1 + [0] This order satisfies following ordering constraints [split(@m)] = [1] @m + [0] >= [1] @m + [0] = [split#1(@m)] [split#1(::(@l, @ls))] = [1] @l + [1] @ls + [1] > [1] @l + [1] @ls + [0] = [split#2(@l, @ls)] [split#1(nil())] = [0] >= [0] = [tuple#2(nil(), nil())] [split#2(::(@x, @xs), @ls)] = [1] @ls + [1] @x + [1] @xs + [1] >= [1] @ls + [1] @xs + [1] = [split#3(split(@ls), @x, @xs)] [split#2(nil(), @ls)] = [1] @ls + [0] >= [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@ys, @m'), @x, @xs)] = [1] @m' + [1] @xs + [1] >= [1] @m' + [1] @xs + [1] = [tuple#2(::(@x, @ys), ::(@xs, @m'))] [transpose^#(@m)] = [1] @m + [1] >= [1] @m + [1] = [transpose#1^#(@m, @m)] [transpose#1^#(::(@xs, @xss), @m)] = [1] @m + [1] > [1] @m + [0] = [split^#(@m)] [transpose#1^#(::(@xs, @xss), @m)] = [1] @m + [1] >= [1] @m + [1] = [transpose#2^#(split(@m))] [split^#(@m)] = [1] @m + [0] >= [1] @m + [0] = [c_24(split#1^#(@m))] [split#1^#(::(@l, @ls))] = [1] @l + [1] @ls + [1] > [1] @ls + [0] = [c_25(split#2^#(@l, @ls))] [split#2^#(::(@x, @xs), @ls)] = [1] @ls + [0] >= [1] @ls + [0] = [c_26(split^#(@ls))] [transpose#2^#(tuple#2(@l, @m'))] = [1] @m' + [1] >= [1] @m' + [1] = [transpose#3^#(@m', @l)] [transpose#3^#(::(@y, @ys), @l)] = [1] @y + [1] @ys + [2] >= [1] @y + [1] @ys + [2] = [transpose^#(::(@y, @ys))] Consider the set of all dependency pairs DPs: { 1: split^#(@m) -> c_24(split#1^#(@m)) , 2: split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , 3: split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , 4: transpose^#(@m) -> transpose#1^#(@m, @m) , 5: transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , 6: transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , 7: transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , 8: transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,5}. These cover all (indirect) predecessors of dependency pairs {1,2,3,5}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) } Weak Trs: { split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { transpose^#(@m) -> transpose#1^#(@m, @m) , transpose#1^#(::(@xs, @xss), @m) -> split^#(@m) , transpose#1^#(::(@xs, @xss), @m) -> transpose#2^#(split(@m)) , split^#(@m) -> c_24(split#1^#(@m)) , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls)) , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls)) , transpose#2^#(tuple#2(@l, @m')) -> transpose#3^#(@m', @l) , transpose#3^#(::(@y, @ys), @l) -> transpose^#(::(@y, @ys)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { split(@m) -> split#1(@m) , split#1(::(@l, @ls)) -> split#2(@l, @ls) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs) , split#2(nil(), @ls) -> tuple#2(nil(), nil()) , split#3(tuple#2(@ys, @m'), @x, @xs) -> tuple#2(::(@x, @ys), ::(@xs, @m')) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded Wall-time: 2.041919s CPU-time: 14.066s Wall-time: 16.797205s CPU-time: 119.25s Hurray, we answered YES(O(1),O(n^4))